4.13 美团笔试 JAVA

第一题：

小美的好矩阵

小美定义一个矩阵是“好矩阵”，当且仅当该矩阵所有元素都相同。现在小美拿到了一个矩阵，她想知道该矩阵有多少2*2的子矩阵是好矩阵？

输入描述

第一行输入两个正整数n和m，代表矩阵的行数和列数。
接下来n行，每行输入m个正整aij，代表小美拿到的矩阵。
1<=n,m<=100
1<=aij<=10^9

输出描述

2*2好子矩阵的数量。

示例 1

输入

3 3
1 2 1
1 1 1
1 1 3

输出

1

说明

只有左下角一个好子矩阵。

思路与代码

关键在于定义二维数组来描述这个矩阵，然后遍历和判断。

import java.util.*;
public class test2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int m = input.nextInt();
        int[] [] matrix = new int [n][m];

        for   (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                matrix[i][j] = input.nextInt();
            }
        }

        int count = 0;

        for (int i = 0; i < n - 1; i++){
            for (int j = 0; j < m - 1; j++){
                if (matrix[i][j] == matrix[i][j+1] && matrix[i][j] == matrix[i+1][j] && matrix[i][j] == matrix[i+1][j+1]){
                    count ++;
                }
            }
        }
        System.out.println(count);
    }
}

 

第二题：

小美的元素加减

小美拿到了一个数组，她可以进行最多k次操作，每次操作任选一个元素加1或者减1。

小美希望最终0的数量尽可能多。你能帮帮她吗？

输入描述

第一行输入2个正整n,k，代表数组大小和小美的操作次数。
第二行输n个整ai，代表小美拿到的数组。
1<=n<=10^5
1<=k<=10^14
-10^9<=ai<=10^9

输出描述

一个整数，代表最终0的数量的最大值。

示例 1

输入

4 5
-2 3 -2 9

输出

2

说明

对第二个元素操作3次减1，对第三个元素操作2次加1，这样数组变成[-2,0,0,9]。

请注意，方案并不是唯一的。但可以证明，0的数量不会超过2个。

思路与代码

+1和-1对于结果都是一样的，因此将所有元素变为正数。

策略是从小的开始去减，直到k不够为止。

import java.util.*;

public class countmaxzero {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        in.nextLine();
        String[] num_string = in.nextLine().split(" ");
        int[] num = new int[num_string.length];
        for (int i = 0; i < num_string.length; i++) {
            num[i] = Integer.parseInt(num_string[i]);
            num[i] = Math.abs(num[i]);
        }
        Arrays.sort(num);

        int count = 0;
        for (int j = 0; j < num.length; j++){
            if (k >= num[j]){
                k -= num[j];
                count ++;
            } else{
                break;
            }
        }
        System.out.println(count);
    }
}

第三题：

小美的红黑树

小美有一棵有 n个节点的树，根节点为1号节点，树的每个节点是红色或者黑色，她想知道有多少节点的子树中同时包含红点和黑点。

输入描述

第一行输入一个整数 n(1<=n<=10^5)表示节点数量。

第二行输入一个长度为 n 的字符串 s 表示节点的颜色，第i 个节点的颜色为si ，若 si 为 'B' 表示节点的颜色为黑色，若 si 为 'R' 则表示节点的颜色为红色。

接下来n-1 行，每行输入两个整数 u,v(1<=u,v<=n)表示树上的边。

输出描述

输出一个整数表示答案。

示例 1

输入

3
BRB
1 2
2 3

输出

2

说明

1号和2号节点的子树都满足条件。

思路与代码

树形dp。dp[i,0]和dp[i,1]分别表示为，以i为根的子树，包含的B和R的数量。转移方程为：dp[i,0] = Σdp[next,0]， dp[i,1]=Σdp[next,1]，其中，next为i的子节点。当然，树形dp的题目不一定要定义dp数组，我们可以直接将每一个节点对应的dp状态返回给父节点，由父节点进行统计即可。

import java.util.*;
public class redblacktree2 {
    static int res = 0;

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String colors = in.next();
　　　　　// 创建一个以邻接链表表示的图 
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i <= n; i++){
            graph.add(new ArrayList<>());
        }
　　　　　// 添加边构建图 
        for (int i = 0; i < n - 1; i++){
            int u = in.nextInt();
            int v = in.nextInt();
            graph.get(u).add(v);
            graph.get(v).add(u);
        }
　　　　　// 从节点1开始执行深度优先搜索 
        dfs(1, -1, colors, graph);
        System.out.println(res);
    }
　　 // 深度优先搜索函数用于遍历图 
    public static int[] dfs(int u, int f, String colors, List<List<Integer>> graph){
        int[] cur = new int[2];
        if (colors.charAt(u-1) == 'B') {
            cur[0] = 1;
        } else {
            cur[1] = 1;
        }
　　　　　// 探索节点u的所有邻居 
        for (int v : graph.get(u)){
            if (v == f){
                continue;
            }
　　　　　　　// 递归调用邻居节点v的dfs 
            int[] cur_v = dfs(v, u, colors, graph);
            cur[0] += cur_v[0];
            cur[1] += cur_v[1];
        }

        // 如果子树中同时存在两种颜色，则结果加一
        if (Math.min(cur[0], cur[1]) > 0){
            res++;
        }
        return cur;
    }
}

 

面试手撕：

import java.util.*;
public class cha_zhao_ju_zhen {
    // 暴力解法
    public int[] look1(int[][] matrix, int n, int m, int x){
        int[] result = new int [2];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                if (matrix[i][j] == x){
                    result[0] = i;
                    result[1] = j;
                }
            }
        }
        return result;
    }

    // 二分法
    public int[] look2(int[][] matrix, int n, int m, int x){
        int[] result = new int [2];
        int length = n * m;
        int left = 0;
        int right = length-1;
        int index = 0;
        int[] list = new int[length];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                list[index++] = matrix[i][j];
            }
        }
        int mid = 0;
        while (left <= right){
            mid = left + (right - left) / 2;
            if (list[mid] == x){
                break;
            } else if (list[mid] > x){
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
　　　　 
　　　　 if (list[mid] != x){
　　　　 　　 mid = 0;
　　　　 }

        result[0] = mid / m;
        result[1] = mid % m;
        return result;
    }

    public static void main(String[] arg){
        int[][] matrix = {{1,2,3},{4,5,6}};
        int n = 2;
        int m = 3;
        int x = 6;
        cha_zhao_ju_zhen obj = new cha_zhao_ju_zhen();
        int[] result = obj.look2(matrix, n, m, x);
        for (int i = 0; i < result.length; i++){
            System.out.print(result[i]);
            if (i < result.length-1){
                System.out.print(" ");
            }
        }
    }
}