3.11美团机试记录

https://tans.fun/archives/2023-3-11-mei-tuan-bi-shi

这位大佬写出来了，坦克模拟没过，这个卷还是算难得了我觉得。

第一题：简单，数多少个连续的，x个就直接x / 2;

import java.util.Scanner;

public class Meituan {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        int res = 0;
        for(int i = 0; i < s.length(); i++) {
            int j = i;
            while(j < s.length() && s.charAt(i) == s.charAt(j)) j++;
            res += (j - i) / 2;
            i = j - 1;
        }
        System.out.println(res);
    }
}

第二题：我的代码过了82%，我dp的，但是当时写得时候还是有点脑子懵懵的，所以代码有点冗余。

import java.util.Scanner;

public class Meituan02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();
        sc.nextLine();
        int[][] color = new int[n][m];
        for(int i = 0; i < n; i++) {
            String s = sc.nextLine();
            for(int j = 0; j < m; j++) {
                if(s.charAt(j) == 'B') {
                    color[i][j] = 1;
                } else if(s.charAt(j) == 'R') {
                    color[i][j] = 0;
                }
            }
        }
        int[][] money = new int[n][m];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                money[i][j] = sc.nextInt();
            }
        }
        int[][] dp = new int[n + 1][m + 1];
        int max = 0;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(i == 0 && j == 0) {
                    continue;
                }
                if(j == 0) {
                    if(dp[i - 1][j] < 0) {
                        dp[i][j] = -1;
                        continue;
                    }
                    dp[i][j] = dp[i - 1][j] + money[i][j];
                    if(color[i][j] != color[i - 1][j]) {
                        dp[i][j] -= k;
                    }
                    max = Math.max(dp[i][j], max);
                    continue;
                }
                if(i == 0) {
                    if(dp[i][j - 1] < 0) {
                        dp[i][j] = -1;
                        continue;
                    }
                    dp[i][j] = dp[i][j - 1] + money[i][j];
                    if(color[i][j - 1] != color[i][j]) {
                        dp[i][j] -= k;
                    }
                    max = Math.max(dp[i][j], max);
                    continue;
                }
                if(dp[i - 1][j] < 0 && dp[i][j - 1] < 0) {
                    dp[i][j] = -1;
                    continue;
                }
                if(dp[i - 1][j] > 0) {
                    int t = dp[i - 1][j] + money[i][j];
                    if(color[i - 1][j] != color[i][j]) t -= k;
                    if(t > dp[i][j]) {
                        dp[i][j] = t;
                    }
                    max = Math.max(max, dp[i][j]);
                }
                if(dp[i][j - 1] > 0) {
                    int t = dp[i][j - 1] + money[i][j];
                    if(color[i][j - 1] != color[i][j]) t -= k;
                    if(t > dp[i][j])  dp[i][j] = t;
                    max = Math.max(max, dp[i][j]);
                }
            }
        }
        System.out.println(max);
    }
}

有点着急了，思路有点乱，浪费了一点时间。

我的逻辑：

第一行第一列：continue;

第一行：只能从左来；

第一列：只能从上来；

否则：可以从左可以从上。

其实没必要做这么多判断，可以直接：

能从左来？从左来。

能从上来？从上来。

从左or从上取个最大。

---

第三题是差分数组的题，但是我没见过差分数组，所以只能模拟然后数了，可能是数据太大了，只过了18%。我的代码如下：

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Meituan03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] b_e = new int[n][2];
        for(int i = 0; i < 2; i++) {
            for(int j = 0; j < n; j++) {
                b_e[i][j] = sc.nextInt();
            }
        }

        int[] begin = new int[n];
        int[] end = new int[n];
        for(int i = 0; i < n; i++) {
            begin[i] = sc.nextInt();
        }
        for(int i = 0; i < n; i++) {
            end[i] = sc.nextInt();
        }
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b)->a[0]-b[0]);
        for(int i = 0; i < n; i++) {
            pq.add(new int[]{begin[i], end[i]});
        }
        int i = 0;
        for(int[] p: pq) {
            begin[i] = p[0];
            end[i++] = p[1];
        }
        int res = 0;
        int lev = 0;
        for(i = 0; i < n; i++) {
            int cnt = 1;
            int b = begin[i];
            int e = end[i];
            for(int j = i + 1; j < n; j++) {
                if(begin[j] <= end[i]) {
                    cnt++;
                    b = begin[j];
                } else
                    break;
            }
            if(res < cnt) {
                res = cnt;
                lev = e - b + 1;
            } else if(res == cnt) {
                lev += e - b + 1;
            }
            res = Math.max(res, cnt);
        }
        System.out.println(res + " " + lev);
    }
}

有一说一有点尴尬，我java的自定义排序都给忘了。。。

package com.company.pdd;

import java.util.Arrays;
import java.util.Comparator;

public class PddTest {
    public static void main(String[] args) {
        int[][] be = new int[5][2];
        for(int i = 0; i < 5; i++) {
            be[i][0] = 5 - i;
            be[i][1] = i;
        }
        for(int[] b: be) {
            System.out.println(b[0] + " " + b[1]);
        }
        Arrays.sort(be, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        for(int[] b: be) {
            System.out.println(b[0] + " " + b[1]);
        }
    }
}

Arrays.sort(数组， + 比较器对象（实现compare方法）。

傻乎乎的放到优先级队列里面。。。也没法出来查

---

第四题：。。。我前三题做的40来分钟吧，中间有卡住的，第四题一看感觉还行哈，但是实现起来给我晕的，，是在干不了。

---

第二卷第一题：这题很可惜，我以为提交了第一卷没发回来改了，所以一直在看第四题，没给这题留时间。。。结果一看，这么简单。。。

考完后我很快写出了下面的代码，不确定对不对。如果把1h留给这题，我怎么着也有60分呀。。。

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Meituan201 {
    static int res = 0;
    static List<Integer>[] father;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        father = new ArrayList[n];
        int[] tree = new int[n];
        String s = sc.nextLine();
        for(int i = 1; i < n; i++) {
            char c = s.charAt(i);
            tree[i] = c == 'B'? 1 : -1;
        }
        for(int i = 1; i < n; i++) {
            int t = sc.nextInt();
            if(father[t] == null) {
                father[t] = new ArrayList<Integer>();
            }
            father[t].add(t);
        }

    }
    public static int[] dfs(int root, int[] tree) {
        int red = 0;
        int blue = 0;
        for(int son: father[root]) {
            int[] r_b = dfs(son, tree);
            red += r_b[0];
            blue += r_b[1];
        }
        if(red == blue) res++;
        int cur = tree[root];
        if(cur == 1) red++;
        else blue++;
        return new int[]{red, blue};
    }

}