拼多多2018年校招真题

拼多多2018年校招真题

题目描述

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

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

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

示例1
输入
3 4 1 2
输出
24

//
// Created by nexta on 2019/2/22.
//

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

int main() {
    int temp;
    vector<long long> max;
    vector<long long> min;
    int n;
    cin >> n;
    while (n--) {
        cin >> temp;
        sort(max.begin(), max.end(), greater<long long>());
        sort(min.begin(), min.end());
        if (max.size() < 3)max.push_back(temp);
        else if (temp > max[2])max[2] = temp;
        if (min.size() < 2)min.push_back(temp);
        else if (temp < min[1])min[1] = temp;
    }

    sort(max.begin(), max.end(), greater<long long>());
    sort(min.begin(), min.end());
    long long a = max[0] * max[1] * max[2];
    long long b = max[0] * min[0] * min[1];
    cout << (a > b ? a : b) << endl;
    return 0;
}

题目描述

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

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

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

示例1
输入
72106547548473106236 982161082972751393

输出
70820244829634538040848656466105986748

import java.math.BigInteger;
import java.util.Scanner;

/**
 * @Desc:java的大整数很好的解决了大整数的相关运算
 * @Date: 2019/2/20 18:25  better late than never. 认真思考，不要直接就动手写
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input[] = scanner.nextLine().split(" ");
        BigInteger a = new BigInteger(input[0]);
        BigInteger b = new BigInteger(input[1]);
        BigInteger c = a.multiply(b);
        System.out.println(c);
    }
}

题目描述

六一儿童节，老师带了很多好吃的巧克力到幼儿园。每块巧克力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

//
// Created by nexta on 2019/2/23.
//

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

int main() {
    int n, m, temp;
    cin >> n;
    int *h = new int[n];
    for (int i = 0; i < n; i++)cin >> h[i];
    cin >> m;
    int *w = new int[m];
    for (int i = 0; i < m; i++)cin >> w[i];

    sort(h, h + n);
    sort(w, w + m);
    int i = 0, j = 0, count = 0;
    while (i < n && j < m) {
        if (h[i] <= w[j]) {
            count++;
            i++;
            j++;
        } else j++;
    }
    cout << count << endl;
}

题目描述

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

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

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

示例1

输入
5 5
02111
01a0A
01003
01001
01111

输出
7

//抄的，真心不会
// Created by nexta on 2019/2/23.
//
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

char G[104][104];
int book[104][104][1040], M, N;
int Next[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};

int bfs(int x, int y);

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("D:/clion/start/input/pdd_D.txt", "r", stdin);
    //freopen("debug/out.txt","w",stdout); //输出重定向，输出数据将保存在out.txt文件中
    while (cin >> N >> M) {
        for (int i = 0; i < N; i++)cin >> G[i];
        memset(book, 0, sizeof(book));
        int flag = 0;
        for (int i = 0; i < N; i++) {
            if (flag == 1)break;
            for (int j = 0; j < M; j++) {
                if (G[i][j] == '2') {
                    flag = 1;
                    book[i][j][0] = 1;
                    cout << bfs(i, j) << endl;
                    break;
                }
            }
        }
    }
    return 0;
}

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 (G[nx][ny] >= 'a' && G[nx][ny] <= 'z') key = key | (1 << (G[nx][ny] - 'a'));
            //碰到门了去匹配钥匙
            if (G[nx][ny] >= 'A' && 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