拼多多2018校招内推编程题汇总

[编程题] 最大乘积

时间限制：1秒
空间限制：32768K

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

输入描述:
无序整数数组A[n]

输出描述:
满足条件的最大乘积

输入例子1:
3 4 1 2

输出例子1:
24

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int main() {
    long n, t;
    cin >> n;
    vector<long> nums(n, 0);
    for(int i = 0; i < n; ++i) {
        cin >> t;
        nums[i] = t;
    }

    //找到最大的三个数和最小的两个数，最终结果为mn1*mn2*mx1 和 mx1*mx2*mx3之间最大的一个
    long mn1 = 0, mn2 = mn1, mx1 = mn1, mx2 = mn1, mx3 = mn1; 
    for(int i = 0; i < n; ++i) {
        if(nums[i]>mx1) {
            mx3 = mx2;
            mx2 = mx1;
            mx1 = nums[i];
        } else if(nums[i] > mx2) {
            mx3 = mx2;
            mx2 = nums[i];
        } else if(nums[i] > mx3) {
            mx3 = nums[i];
        } else if(nums[i] < mn1) {
            mn2 = mn1;
            mn1 = nums[i];
        } else if(nums[i] < mn2) {
            mn2 = nums[i];
        }
    }
    long res;           //乘积太大，int double结果会溢出或是不精确，最后采用long型可以AC
    if(mn1*mn2*mx1 > mx1*mx2*mx3)
        res = mn1*mn2*mx1;
    else
        res = mx1*mx2*mx3;
    cout << res;
    return 0;
}

[编程题] 大整数相乘

时间限制：1秒
空间限制：32768K

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

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

输出描述:
输入的乘积，用字符串表示

输入例子1:
72106547548473106236 982161082972751393

输出例子1:
70820244829634538040848656466105986748

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
    string s1, s2;
    cin >> s1;
    cin >> s2;
    int n1, n2, n;
    n1 = s1.size();
    n2 = s2.size();
    n = n1+n2;
    vector<int> tmp(n,0);
    for(int i = 0; i < n1; ++i) {
        for(int j = 0; j < n2; ++j) {
        //按位相乘，并相加存入数组， 注意在字符串中s[0]表示的是最高位数字
            tmp[n1-i-1+n2-j-1] += (s1[i] - '0') * (s2[j] - '0'); 
        }
    }

    int carry = 0;
    string res(n,'0');
    for(int i = 0; i < n; ++i) {  //从最低位开始，逐位进行进位运算
        tmp[i] += carry;
        carry = tmp[i]/10;
        tmp[i]= tmp[i]%10;
        res[n-i-1] += tmp[i];
    }

    int i = 0;
    while(res[i++] == '0') {};  //去除高位上的“0”字符
    res.erase(res.begin(), res.begin()+i-1);
    cout << res;

    return 0;
}

[编程题] 六一儿童节

时间限制：1秒
空间限制：32768K

六一儿童节，老师带了很多好吃的巧克力到幼儿园。每块巧克力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<algorithm>
#include<vector>
using namespace std;
int main() {
    int n1,n2;
    cin >> n1;
    vector<int> h(n1);
    for(int i = 0; i < n1; ++i) {
        cin >> h[i];
    }
    cin >> n2;
    vector<int> w(n2);
    for(int i = 0; i < n2; ++i) {
        cin >> w[i];
    }
    sort(h.begin(), h.end());   //排序操作
    sort(w.begin(), w.end());
    int res = 0;
    int idx1 = n1-1;     //定义数组的下表索引值
    int idx2 = n2-1;
    while(idx1 >= 0 && idx2 >= 0) {
        if(w[idx2] >= h[idx1]) {
            ++res;
            --idx1;
            --idx2;
        } else {
            --idx1;
        }
    }
    cout << res;
    return 0;
}

[编程题] 迷宫寻路

时间限制：1秒
空间限制：131072K

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

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

输出描述:
路径的长度，是一个整数

输入例子1:
5 5
02111
01a0A
01003
01001
01111

输出例子1:
7

DFS程序如下，只通过20%：

#include<iostream>
#include<algorithm>
#include<vector>
#include<limits.h>
#include<string>
#include<unordered_map>
using namespace std;


void dfs(vector<string> &map, unordered_map<char, bool> &m, int i, int j, int path, vector<int> &res, vector<vector<bool>> &idx) {
    int M = map.size();
    int N = map[0].size();
    if(i < 0 || i >= M || j < 0 || j >= N) return;

    if(map[i][j] == '3') {
        res.push_back(path);      //找到终点，将路径长度path存入res
        idx[i][j] = false;
        return;
    }
    if(map[i][j] == '0') {
        return;
    }
    if(idx[i][j]) return;   //判断是否已经访问过该点
    idx[i][j] = true;      

    if(map[i][j] == '2') {
        dfs(map, m, i, j+1, path+1, res, idx);
        dfs(map, m, i, j-1, path+1, res, idx);
        dfs(map, m, i+1, j, path+1, res, idx);
        dfs(map, m, i-1, j, path+1, res, idx);
    }
    else if(map[i][j] == '1') {
        dfs(map, m, i, j+1, path+1, res, idx);
        dfs(map, m, i, j-1, path+1, res, idx);
        dfs(map, m, i+1, j, path+1, res, idx);
        dfs(map, m, i-1, j, path+1, res, idx);
    }
    else if(map[i][j] >= 'a' && map[i][j] <= 'z') {  
        m[map[i][j] - 32] = true;                     //访问钥匙
        dfs(map, m, i, j+1, path+1, res, idx);
        dfs(map, m, i, j-1, path+1, res, idx);
        dfs(map, m, i+1, j, path+1, res, idx);
        dfs(map, m, i-1, j, path+1, res, idx);
        m[map[i][j] - 32] = false;                 //访问钥匙状态还原
    }
    else if(map[i][j] >= 'A' && map[i][j] <= 'Z') {
        if(m[map[i][j]] == true) {                  //判断是否访问过对应钥匙
            dfs(map, m, i, j+1, path+1, res, idx);
            dfs(map, m, i, j-1, path+1, res, idx);
            dfs(map, m, i+1, j, path+1, res, idx);
            dfs(map, m, i-1, j, path+1, res, idx);
        }

    }
    idx[i][j] = false;
    return;
}

vector<int> locate(vector<string> &map, char ch) {  //定位函数
    vector<int> pos(2, -1);
    int i,j;
    int M = map.size();
    int N = map[0].size();
    for(i = 0; i < M; ++i) {
        for(j = 0; j < N; ++j) {
            if(map[i][j] == ch) {
                pos[0] = i;
                pos[1] = j;
                return pos;
            }
        }
    }
    return pos;
}
int main() {
    int M,N,i,j;
    unordered_map<char, bool> m;
    cin >> M >> N;
    vector<string> map(M);
    for(i = 0; i < M; ++i) {
        cin >> map[i];
        for(j = 0; j < N; ++j) {
            if(map[i][j]>='A' && map[i][j]<='Z')   
                m[map[i][j]] = false;      //记录门的种类，存入哈希表
        }
    }
    vector<vector<bool>> idx(M, vector<bool>(N, false)); //记录是否访问某点
    vector<int> star(2);
    star = locate(map, '2');       //找到起始位置
    if(star[0] == -1 && star[1] == -1)
        return 0;

    vector<int> res;
    dfs(map, m, star[0], star[1], 0, res, idx);   //迭代运算

    int ans = INT_MAX;
    for(i = 0; i < res.size(); ++i) {   //找到最短路径
        if(res[i] < ans)
            ans = res[i];
    }
    cout << ans;

    return 0;
}

BFS程序（网上找的答案）：

//AC代码:
#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;
                }
        }
    }
}
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'));
            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
 //比如我现在有第二把钥匙和第四把钥匙  那么我的钥匙状态就是 0101000000 也就是 320