【笔试】阿里2020/03/23JAVA岗笔试题

第一题

问题简述

从n个人中选择任意数量的人员组成一支队伍，然后从一支队伍中选出一位队长，不同的队长算不同的组合，问这样的组合的数量对取模（还是取余来着？）是多少

解决思路

本质：纯数学题

其实组合数量可以直接通过组合公式得到，如下所示

然后，让 倒转并相加，即

然后，根据组合公式的对称性，即，公式可简化为

最后，根据定理，所以组合数量：

所以，整道题的答案就是。

目前，整道题最大的瓶颈在于「如何快速求出」

// 基于二分求幂
// O(log(n))
public static double power(double base, int exponent){
    double res = 1;
    while (exponent > 0){
        if (exponent % 2 == 1)
            res *= base;
        base *= base; // 翻倍
        exponent >>= 1; //相当于除2
    }
    return res;
}

代码实现

申明，这个代码是笔试结束后写的，所以并没有跑笔试中的测试用例

// 时间复杂度==power中的 O(log(n))
public long f(int n){
    return (n*power(2, n-1)) % 100000007; 
}

参考

[1] 阿里笔试讨论（3.23场)（附两道题AC的方法或代码）技术交流牛客网
[2] 快速求幂算法Java实现Java白衣-CSDN博客

第二题

问题简述

一个地图n*m，包含1个起点，1个终点，其他点包括可达点和不可达点。
每一次可以：上下左右移动，或使用1点能量从（i,j)移动到（n-1-i, m-1-j)，最多可以使用5点能量。

解题思路

本质是一个迷宫问题。迷宫问题的解题思路有

• 深度遍历
• 广度遍历。其中广度遍历的最大好处就是找到的第一条路径就是最短路径。

与普通迷宫问题的区别在于“本题允许进行 5 次对称跳跃”。

代码实现

摘自：阿里笔试讨论（3.23场)（附两道题AC的方法或代码）技术交流牛客网

/*
AC 代码
空间复杂度O(m*n*6), 时间复杂度O(m*n*6)
考试时写的比较草率，没有好好做函数化，简单加点注释供讨论
简单来说思路是类似于广度优先搜索的，但也写成了偏dp的样子……
dp[i][j][k]：用了k次飞行器时，达到这个位置(i,j)最小需要的步数
用队列来进行访问：
1. 首先把起点坐标放入队列
2. 每一次访问队头元素，观察其1步可以到达的（上、下、左、右、中心对称位）的坐标：
   如果该坐标当前记录的某一种飞行器使用次数k下的值>当前值+1，则更新该值，把这一坐标加入队列
   （注意，上、下、左、右是同k值比较，中心对称位需要使用一次飞行器，所以是k+1和K比较）
3. 队列清空，更新完成
给出终点目前记录的步数，即为结果
*/
 
/*
可能的优化：
因为队列入队时，肯定越到后面步数需要越多，所以其实第一次访问到终点坐标就可以跳出了，
不过已经AC了就不想改了……
*/
 
#include
#include
#include
using namespace std;
 
//定义坐标点
struct pos{
    int x;
    int y;
};
 
int main() {
    int n,m;
    cin>>n>>m;
    vector > M;
    vector vtmp;
    queue q1;
    pos ps, pe, ptmp;
    char ctmp;
    int dp[n][m][6];
    bool flag;
    int i,j, k;
     
    //先把每个位置设置一个大值
    for(i = 0; i < n; i++) {
        for(j = 0; j < m; j++) {
            for(k = 0; k < 6; k++) {
                dp[i][j][k] = n*m+1;
            }
        }
    }
     
    //输入 && 记录起点、终点
    for(i = 0; i < n; i++) {
        for(j = 0; j < m; j++) {
            cin>>ctmp;
            vtmp.push_back(ctmp);
            if(ctmp == 'S') {
                ps.x = i;
                ps.y = j;
                q1.push(ps);
                for(k = 0; k < 6; k++) {
                    dp[i][j][k] = 0;
                }
            }
            else if(ctmp == 'E') {
                pe.x = i;
                pe.y = j;
            }
        }
        M.push_back(vtmp); // 起点入队
        vtmp.clear();
    }
     
    //类似广度优先遍历的走完地图
    while(!q1.empty()) {
        ptmp = q1.front();
         
        // 尝试向上走
        if(ptmp.x > 0 && M[ptmp.x - 1][ptmp.y] != '#') {
            flag = 0;
            for(k = 0; k < 6; k++) {
                // 更新dp数组。在k相同的条件下，如果当前格的上面一格的dp值大于当前格直接向上走得到的步数，就需要更新dp[上面一个][k]
                if(dp[ptmp.x-1][ptmp.y][k] > dp[ptmp.x][ptmp.y][k] + 1) {
                    dp[ptmp.x-1][ptmp.y][k] = dp[ptmp.x][ptmp.y][k] + 1;
                    flag = 1;
                }
            }
            // dp[i][j][k]记录的是用了k次飞行器时，达到这个位置(i,j)最小需要的步数
            // flag==1,说明：当前格直接向上走产生的步数小于之前记录的dp值，只有这种才有必要把当前格的上面一格压入队列。
            if(flag == 1) { 
                ps.x = ptmp.x-1;
                ps.y = ptmp.y;
                q1.push(ps);
            }
        }
        
        // 尝试向下走
        if(ptmp.y > 0 && M[ptmp.x][ptmp.y - 1] != '#') {
            flag = 0;
            for(k = 0; k < 6; k++) {
                if(dp[ptmp.x][ptmp.y-1][k] > dp[ptmp.x][ptmp.y][k] + 1) {
                    dp[ptmp.x][ptmp.y-1][k] = dp[ptmp.x][ptmp.y][k] + 1;
                    flag = 1;
                }
            }
            if(flag == 1) {
                ps.x = ptmp.x;
                ps.y = ptmp.y-1;
                q1.push(ps);
            }
        }
         
        // 尝试向右走
        if(ptmp.x < n-1 && M[ptmp.x + 1][ptmp.y] != '#') {
            flag = 0;
            for(k = 0; k < 6; k++) {
                if(dp[ptmp.x+1][ptmp.y][k] > dp[ptmp.x][ptmp.y][k] + 1) {
                    dp[ptmp.x+1][ptmp.y][k] = dp[ptmp.x][ptmp.y][k] + 1;
                    flag = 1;
                }
            }
            if(flag == 1) {
                ps.x = ptmp.x+1;
                ps.y = ptmp.y;
                q1.push(ps);
            }
        }
        
        // 尝试向左走
        if(ptmp.y < m-1 && M[ptmp.x][ptmp.y +1] != '#') {
            flag = 0;
            for(k = 0; k < 6; k++) {
                if(dp[ptmp.x][ptmp.y+1][k] > dp[ptmp.x][ptmp.y][k] + 1) {
                    dp[ptmp.x][ptmp.y+1][k] = dp[ptmp.x][ptmp.y][k] + 1;
                    flag = 1;
                }
            }
            if(flag == 1) {
                ps.x = ptmp.x;
                ps.y = ptmp.y+1;
                q1.push(ps);
            }
        }
         
        //尝试中心对称走，k->k+1更新
        if(M[n - 1 - ptmp.x][m - 1 - ptmp.y] != '#') {
            flag = 0;
            for(k = 0; k < 5; k++) {
                if(dp[n - 1 - ptmp.x][m - 1 - ptmp.y][k+1] > dp[ptmp.x][ptmp.y][k] + 1) {
                    dp[n - 1 - ptmp.x][m - 1 - ptmp.y][k+1] = dp[ptmp.x][ptmp.y][k] + 1;
                    flag = 1;
                }
            }
            if(flag == 1) {
                ps.x = n - 1 - ptmp.x;
                ps.y = m - 1 - ptmp.y;
                q1.push(ps);
            }
        }
        q1.pop();
    }
     
     
    if(dp[pe.x][pe.y][5] == n*m+1) {
        cout<<-1<