实习机试代码记录

2023-03-11 美团机试

题目：美团2024届暑期实习第一轮后端笔试详解
通过了前三道，花了一堆时间在第四道上，一分没得，第五题都没时间看。题目的设置有点无语，一到四题安排在一起，第五题安排在一起，当时不知道提交后可以继续修改，进了一到四题的项就不敢提交，以为第五题单独放一起肯定很难，最后没时间了看了一下第五题，比较简单。搞不明白为啥要把第五题单独列一个项，要不然怎样都能写出四道来

第一题

小美有一个由数字字符组成的字符串。现在她想对这个字符串进行一些修改。 具体地，她可以将文个字符串中任意位置字符修改为任意的数字字符。她想知道，至少进行多少次修改，可以使得“修改后的字符串不包含两个连续相同的字符?
例如，对于字符串”111222333”, 她可以进行3次修改将其变为” 121212313”。输入描述
一行，一个字符串s，保证s只包含数字字符。1<=|s|<= 100000输出描述
一行，一个整数，表示修改的最少次数。

思路
简单题，遇见相同的字符直接改成数字字符之外的‘a’即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <bits/stdc++.h>
using namespace std;

int main() {
  string s;
  while (cin >> s) {
    int cnt = 0;
    for (int i = 1; i < s.length(); i++) {
      if (s[i] == s[i - 1]) {
        s[i] = 'a';
        cnt++;
      }
    }
    cout << cnt << endl;
  }
}
CPP

第二题

小团在一个n*m的网格地图上探索。 网格地图上第i行第j列的格子用坐标(i,j)简记。初始时，小团的位置在地图的左上角，即坐标(1,1)。 地图上的每个格子 上都有一定的金币， 特别地，小团位于的初始位置(1,1)上的金币为0。小团在进行探索移动时，可以选择向右移动-格(即从(x,y)到达(x,y+1))或向下移动一格(即从(x,y)到达(x+1,y)) 。地图上的每个格子都有一个颜色，红，色或蓝色。如果小团次移动前后的两个格子颜色不同，那么他需要支付k个金币才能够完成这-次移动;如果移动前后的两个格子颜色相同，则不需要支付金币。小团可以在任意格子选择结束探索。现在给你网格地图上每个格子的颜色与金币数量，假设小团初始时的金币数量为0，请你帮助小团计算出最优规划，使他能获得最多的金币，输出能获得的最多 金币数量即可。注意:要求保证小团任意时刻金币数量不小于零。

输入描述
第一行是三个用空格隔开的整数n、m和k，表示网格地图的行数为n,列数为m,在不同颜色的两个格子间移动需要支付k个金币。
接下来n行，每行是一个长度为m的字符串， 字符串仅包含字符R’或’ B’。第i行字符串的第j个字符表示地图上第i行第j列的格子颜色，如果字符为’ R’ 则表示格子颜色为红色，为’B’ 表示格子颜色为蓝色。
接下来是个n行m列的非负整数矩阵，第i行第j列的数字表示地图上第行第j列的格子上的金币数量。保证所有数据中数字大小都是介于[0, 10]的整数。
1<=n,m<=200, 1<=k<=5。

思路
刚开始直接暴力回溯，运行超时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <bits/stdc++.h>
using namespace std;

// 定义全局变量
string color[201];
int coin_num[201][201];
int n, m, k;
int max_coin_num;

void dfs(int x, int y, int cur_coin_num) {
  max_coin_num = max(max_coin_num, cur_coin_num);
  if (x + 1 < n) {  // 向下移动
    int offer = color[x][y] == color[x + 1][y] ? 0 : -k;
    if (cur_coin_num + offer >= 0) {
      dfs(x + 1, y, cur_coin_num + offer + coin_num[x + 1][y]);
    }
  }
  if (y + 1 < m) {  // 向右移动
    int offer = color[x][y] == color[x][y + 1] ? 0 : -k;
    if (cur_coin_num + offer >= 0) {
      dfs(x, y + 1, cur_coin_num + offer + coin_num[x][y + 1]);
    }
  }
}
int main() {
  while (cin >> n >> m >> k) {
    for (int i = 0; i < n; i++) {
      cin >> color[i];
    }
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        cin >> coin_num[i][j];
      }
    }
    max_coin_num = 0;
    dfs(0, 0, 0);
    cout << max_coin_num << endl;
  }
}
CPP

后面用动态规划写了一个版本，通过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <bits/stdc++.h>
using namespace std;

int main() {
  string color[201];
  int coin_num[201][201];
  int n, m, k;
  while (cin >> n >> m >> k) {
    for (int i = 0; i < n; i++) {
      cin >> color[i];
    }
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        cin >> coin_num[i][j];
      }
    }
    int ans = 0;
    vector<vector<int>> max_coin_num(n, vector<int>(m, -1));  // 全部设成-1，不可达
    max_coin_num[0][0] = 0;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        int value = -1;
        if (i - 1 >= 0) {  // 从上方转移而来
          int offer = color[i][j] == color[i - 1][j] ? 0 : -k;
          value = max(value, max_coin_num[i - 1][j] + offer);
        }
        if (j - 1 >= 0) {  // 从左边转移而来
          int offer = color[i][j] == color[i][j - 1] ? 0 : -k;
          value = max(value, max_coin_num[i][j - 1] + offer);
        }
        if (value >= 0) {  // 进行状态转移
          max_coin_num[i][j] = value + coin_num[i][j];
        }
      }
    }
    // 计算最大金币数目
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        ans = max(ans, max_coin_num[i][j]);
      }
    }
    cout << ans << endl;
  }
}
CPP

第三题

小美是位天文爱好者， 她收集了接下来段时间中所有 会划过她所在的观测地上空的流星信息。具体地，她收集了n个流星在她所在观测地上空的出现时刻和消失时刻。对于一个流星，若’其的出现时刻为s，消失时刻为t，那么小美在时间段[s, t]都能够观测到它。对于一个时刻，观测地上空出现的流星数量越多，则小美认为该时刻越好。小美希望能够选择一个最佳的时刻进行观测和摄影，使她能观测到最多数量的流星。现在小美想知道 ，在这个最佳时刻，她最多能观测到多少个流星以及一共有多少个最佳时刻可供她选择。

输入描述
第一行是一个正整数n,表示流星的数量。
第二行是n个用空格隔开的正整数，第i个数si表示第i个流星的出现时间。
第三行是n个用空格隔开的正整数，第i个数ti表示第i个流星的消失时间。
1<=n<=100000, 1<=si<=ti<=10^9
输出描述
输出一行用空格隔开的两个数x和y,其中x表示小美能观测到的最多流星数，y表示可供她选择的最佳时刻数量。

思路
排序，从左往右计算可观测的流星数量，不过后面看别人说标准解法是差分数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <bits/stdc++.h>
using namespace std;

struct Node {
  int value;      // 时间
  bool is_start;  // 是否为起始观测时间
  int number;     // 观测流星数目
};

int main() {
  int n, s, t;
  while (cin >> n) {
    vector<Node> star(2 * n);
    for (int i = 0; i < n; i++) {
      cin >> s;
      star[i].value = s;
      star[i].is_start = true;
    }
    for (int i = n; i < 2 * n; i++) {
      cin >> t;
      star[i].value = t;
      star[i].is_start = false;
    }
    auto cmp = [&](const Node& n1, const Node& n2) -> bool { return n1.value < n2.value || (n1.value == n2.value && n1.is_start == true); };  // 尽可能让起始观测时间在终止观测时间之前
    sort(star.begin(), star.end(), cmp);
    int observer = 0;
    int max_observer = 0;
    for (int i = 0; i < 2 * n; i++) {
      if (star[i].is_start) {  // 遇到起始时间，观测数加一
        observer++;
        star[i].number = observer;
      } else {  // 遇到终止时间，当前观测数不变，之后观测数减一
        star[i].number = observer;
        observer--;
      }
      max_observer = max(max_observer, star[i].number);
    }
    int time_num = 0;
    for (int i = 0; i < 2 * n; i++) {
      if (star[i].number == max_observer) {  // 一定为start-end组合，跳过end节点
        time_num += star[i + 1].value - star[i].value + 1;
        i++;
      }
    }
    cout << max_observer << " " << time_num << endl;
  }
}
CPP

第四题

小D和小W最近在玩坦克大战，双方操控自己的坦克在16*1 6的方格图上战斗，小D的坦克初始位置在地图的左上角，朝向为右，其坐标(0,0)， 小W的坦克初始位置在地图右下角，朝向为左，坐标为(15,15)。坦克不能移动到地图外，坦克会占领自己所在的格子，己方的坦克不可以进入对方占领过的格子。每一个回合双方必须对自己的坦克下达以下5种指令中的一种:
.移动指令U:回合结束后，使己方坦克朝向为上，若上方的格子未被对方占领，则向当前朝向移动一个单位(横坐标-1)，否则保持不动;
.移动指令D:回合结束后，使己方坦克朝向为下，若下方的格子未被对方占领，则向当前朝向移动一个单位(横坐标+1)，否则保持不动，
.移动指令L:回合结束后，使己方坦克朝向为左,若左侧的格子未被对方占领，则向当前朝向移动一个单位(纵坐标-1) ,否则保持不动;
.移动指令R:回合结束后，使己方坦克朝向为右，若右侧的格子未被对方占领，则向当前朝向移动一个单位(纵坐标+1)，否则保持不动;
. 开火指令F:己方坦克在当前回合立即向当前朝向开火;

己方坦克开火后，当前回合己方坦克的正前方若有对方的坦克，对方的坦克将被摧毁，游戏结束，己方获得胜利;若双方的坦克在同一-回合被摧毁，游戏结束，判定为平局;若双方的坦克在同一回合内进入到同一个未被占领的格子，则双方的坦克发生碰撞，游戏结束，判定为平局;当游戏进行到第256个回合后，游戏结束，若双方坦克均未被摧毁，则占领格子数多的一方获得胜利，若双方占领的格子数一样多，判定为平局。*注意， 若-方开火， 另-方移动，则认为是先开火，后移动。

现在小D和小W各自给出一串长度为256的指令字符串， 请你帮助他们计算出游戏将在多少个回合后结束，以及游戏的结果。

输入描述
输入共两行，每行为一串长度为256的指令宁符串，字符串中只包含“U”，“D”，“L” “R”，“F”这五个字符。第一行表示小D的指令，第工行表示小W的指令。
输出描述
输出一共两行，第一行一个整数k，表示游戏将在k个回合后结束。第二行为游戏的结 果，若小D获胜则输出“D”，若小W获胜则输出“W”若平局则输出“P”

思路
大模拟，40分钟一分没得，懒得贴代码了

第五题

给一棵有n个点的有根树，点的编号为1到n，根为1。每个点的颜色是红色或者蓝色。对于树上的一个点，如果其子树中(不包括该点本身)红色点和蓝色点的数量相同，那么我们称该点是平衡的。

请你计算给定的树中有多少个点是平衡点。

输入描述
第一行是一个正整数n，表示有n个点。
接下来行一个长度为n的字符串，仅包含字符R’和’B’， 第i个字符表示编号为的节点的颜色，字符为’R’ 表示红色，’ B’ 表示蓝色。
接下来一行n-1个用空格隔开的整数，第1个整数表示编号为i+ 1的点的父亲节点编号。1<=n<=10000

输出描述
一行一个整数，表示树上平衡点的个数。

思路
没写，无语的题目安排

2023-03-12 拼多多机试

题目链接： 2023暑期实习-笔试-拼多多-算法实习生
晚上的笔试，过了三道半

第一题 多多的压缩编码II

还原压缩后的字符串
输入 10a1b1c
输出 aaaaaaaaaabc

思路
简单题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <bits/stdc++.h>
using namespace std;

int main() {
  string s;
  while (cin >> s) {
    string ans = "";
    int number = 0;
    for (char c : s) {
      if (c >= '0' && c <= '9') {  // 遇见数字
        number = number * 10 + c - '0';
      } else {                     // 遇见字母
        ans += string(number, c);  // 添加number个字符c
        number = 0;
      }
    }
    cout << ans << endl;
  }
}
CPP

第二题 多多的飞机大战游戏

多多最近下载了一款飞机大战的游戏，多多可以通过游戏上的不同发射按键来控制飞机发射子弹：
按下A键，飞机会发射出2枚子弹，每个子弹会对命中的敌人造成1点固定伤害，但不能作用于同个敌人。
按下B键，飞机会发射出1枚子弹，子弹会对命中的敌人造成巨额伤害并瞬间将其秒杀。

多多是个游戏高手，总是能操控子弹命中想要命中的敌人。这个游戏—共有 T 个关卡，消灭当前关卡全部敌人后，发射出去多余的子弹会消失，游戏会自动进入下一个关卡。
假设每个关卡都会在屏幕中同时出现N个敌人，这N个敌人所能承受的伤害也已经知道。多多想知道，每个关卡自己最少按几次发射按键就可以将敌人全部消灭。
输入描述
第一行输入一个固定数字T（1<=T=1000）表示关卡的总数量，N（1<=N<=200）表示每个关卡出现的敌人数量。
接下来T行，每行有N个数字D1，D2，…，Dw（1<= Di <= 200）分别表示这N个敌人所能承受的伤害。

输出描述
结果共有N行，每行一个数字，分别表示对于这个关卡，最少按几次发射按键就可以将敌人全部消灭。

思路
承受伤害为1按A键，大于1则直接按B键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <bits/stdc++.h>
using namespace std;

int main() {
  int t, n;
  while (cin >> t >> n) {
    for (int i = 0; i < t; i++) {
      int di;
      unordered_map<int, int> cnt;  // 承受伤害敌人与相应数目
      for (int j = 0; j < n; j++) {
        cin >> di;
        cnt[di]++;
      }
      int ans = 0;
      for (auto& [damage, num] : cnt) {
        if (damage == 1) {       // 全部选择A键
          ans += (num + 1) / 2;  // 向上取整
        } else {                 // 全部选择B键
          ans += num;
        }
      }
      cout << ans << endl;
    }
  }
}
CPP

第三题 多多的团建计划

多多君准备了三个活动（分别编号A、B和C)，每个活动分别有人数上限以及每个人参加的费用。
参加团建的有N个人(分别编号1~N），每个人先投票选择若干个意向的活动，最终每个人只能参加其中一个。
多多君收集完投票结果后，发现如何安排成为了大难题：如何在满足所有人的意向的情况下，使得活动的总费用最少。
于是多多君找到了擅长编程的你，希望你能帮助找到个合理的团建计划。

输入描述
第一行，一个整数N（1<=N<=100），代表准备参加活动的人数。
接下来N行，每行一个由 “ABC” 组成的字符串，其中第i行表示第i个人投票了哪几个活动。输入保证字符串非空，且由大写的 “ABC” 字符组成。
最后三行，每行两个整数，分别表示三个活动的人数上限以及每个人参加的费用。
输出描述
输出共2行
如果能满足所有人的要求，第一行输出 “YES”，第二行输出最少的总费用。
如果不能满足所有人的要求，第一行输出 “NO”，第二行输出最多能满足多少人。

思路
本来想用贪心，但觉得贪心策略不一定对，就直接用dfs暴力枚举所有可能了，好像得了40-60分，太久了，忘了
但使用贪心虽然得不到满分，也有80-90分了，不能一昧地暴力回溯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include <bits/stdc++.h>
using namespace std;

// 全局变量
const int kINf = 1 << 30;
int n;
vector<string> vote(101);  // 每个人投票的活动
vector<int> limit(3);      // 活动限制
vector<int> money(3);      // 活动费用
int min_total;             // 最小总费用
int max_require;           // 最多满足多少人
bool can_all_require;      // 是否能满足

int get_money(const vector<int>& origin_limit, const vector<int>& cur_limit) {  // 通过活动名额差值计算总费用
  int total_money = 0;
  for (int i = 0; i < 3; i++) {
    total_money += (origin_limit[i] - cur_limit[i]) * money[i];
  }
  return total_money;
}

bool is_all_zero(const vector<int>& cur_limit) { return cur_limit[0] == 0 && cur_limit[1] == 0 && cur_limit[2] == 0; }  // 活动是否全部参加完

void dfs(int cur_index, vector<int> cur_limit, int cur_require) {
  if (cur_index >= n || is_all_zero(cur_limit)) {               // 当前下标越界或活动全部参加完
    if (cur_require == n) {                                     // 已经满足所有人
      min_total = min(min_total, get_money(limit, cur_limit));  // 计算最小总费用
      can_all_require = true;                                   // 可以满足所有人
    } else {
      max_require = max(max_require, cur_require);  // 计算最多满足人数
    }
    return;
  }
  if (vote[cur_index].length() == 1) {  // 如果只有一个人（好像和下面的代码冗余了，不知道我当时怎么想的）
    char c = vote[cur_index][0];
    if (cur_limit[c - 'A'] > 0) {  // 当前活动尚有名额
      cur_limit[c - 'A']--;
      dfs(cur_index + 1, cur_limit, cur_require + 1);
      cur_limit[c - 'A']++;
    } else {
      if (can_all_require) {  // 已经存在满足所有人的选择，略过当前选择
        return;
      }
      dfs(cur_index + 1, cur_limit, cur_require);  // 不考虑该人
    }
  } else {
    for (char c : vote[cur_index]) {  // 依次选择各个活动
      if (cur_limit[c - 'A'] > 0) {
        cur_limit[c - 'A']--;
        dfs(cur_index + 1, cur_limit, cur_require + 1);
        cur_limit[c - 'A']++;
      }
    }
    if (can_all_require) {  // 已经存在满足所有人的选择，略过当前选择
      return;
    }
    dfs(cur_index + 1, cur_limit, cur_require);  // 不考虑该人
  }
}

int main() {
  while (cin >> n) {
    for (int i = 0; i < n; i++) {
      cin >> vote[i];
    }
    for (int i = 0; i < 3; i++) {
      cin >> limit[i] >> money[i];
    }

    min_total = kINf;
    max_require = 0;
    can_all_require = false;
    dfs(0, limit, 0);
    if (min_total == kINf) {  // 不能满足所有人
      cout << "NO" << endl << max_require << endl;
    } else {  // 可以满足所有人
      cout << "YES" << endl << min_total << endl;
    }
  }
}
CPP

第四题 多多的餐厅客流量

多多君开了一家自助餐厅，为了更好地管理库存，多多君每天需要对之前的客流量数据进行分析，并根据客流量的平均数和中位数来制定合理的备货策略。
输入描述
第一行一个整数N,表示餐厅营业总天数(0<n<=200,000),< p=””></n<=200,000),<>
第二行共N个整数,分别表示第i天的客流量R:(0= R:1, 000, 000)。

输出描述
输出共两行：
第一行长度为N，其中第i个值表示前i天客流量的平均值；第二行长度为N，其中第i个值表示前i天客流量的中位数。
一共有N天，每天的客流量为 Ri，求第1天到第i天的平均数和中位数，结果四舍五入保留整数。

思路
没啥思路，就用插入排序过了，标准方法是295. 数据流的中位数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <bits/stdc++.h>
using namespace std;

int GetInterge(double d) {  // 四舍五入
  int n = d;
  double test = n + 0.5;
  if (d >= test) {
    return n + 1;
  }
  return n;
}
void InsertSort(vector<int>& vec, int val) {  // 借助二分查找实现插入排序
  auto iter = upper_bound(vec.begin(), vec.end(), val);
  vec.emplace(iter, val);
}

int main() {
  int n;
  while (cin >> n) {
    vector<int> vec;
    vector<int> avg(n + 1);
    vector<int> mid(n + 1);
    double sum = 0;
    for (int i = 1; i <= n; i++) {
      int r;
      cin >> r;
      sum += r;
      avg[i] = GetInterge(sum / i);  // 求平均值
      InsertSort(vec, r);
      double tmp = vec[i / 2] + vec[(i - 1) / 2];
      mid[i] = GetInterge(tmp / 2);  // 求中位数
    }
    // 输出结果
    for (int i = 1; i <= n; i++) {
      cout << avg[i] << " ";
    }
    cout << endl;
    for (int i = 1; i <= n; i++) {
      cout << mid[i] << " ";
    }
    cout << endl;
  }
}
CPP

2023-3-15 阿里机试

题目链接: 大厂真题|3月15日阿里春招笔试三道题
晚上的笔试，七道单选，八道多选，三道编程题，编程题过了2道半，不能使用本地IDE，故没当时的代码（临结束的时候应该把所有的代码拷贝到剪切板的）

第一题


思路
满二叉树，首先根据数组构建二叉树，而后寻找根节点，最后递归求解满二叉树，仅当两个子树皆为满二叉树且节点数目相同时该树为满二叉树

按记忆打的，不一定对

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <bits/stdc++.h>
using namespace std;

struct TreeNode {
  TreeNode* left;
  TreeNode* right;
  TreeNode() : left(nullptr), right(nullptr) {}
};
using Result = pair<int, bool>;  // 节点数量-是否为满二叉树

Result GetNodeInfo(TreeNode* node, int& full_node_num) {
  if (node == nullptr) {  // 空节点
    return {0, true};
  }
  Result left_info = GetNodeInfo(node->left, full_node_num);
  Result right_info = GetNodeInfo(node->right, full_node_num);
  bool is_full = (left_info.first == right_info.first) && left_info.second && right_info.second;  // 两个子节点均为满二叉树且节点数目一致
  int nodes = left_info.first + right_info.first + 1;
  if (is_full) {  // 满二叉树节点加一
    full_node_num++;
  }
  return {nodes, is_full};
}

int main() {
  int n;
  while (cin >> n) {
    vector<TreeNode> tree_node(n + 1);  // 树节点
    vector<bool> appear(n + 1, false);  // 节点是否出现在输入中
    // 构建二叉树
    for (int i = 1; i <= n; i++) {
      int x, y;
      cin >> x >> y;
      if (x != -1) {
        tree_node[i].left = &tree_node[x];
        appear[x] = true;
      }
      if (y != -1) {
        tree_node[i].right = &tree_node[y];
        appear[y] = true;
      }
    }
    // 寻找根节点（未出现的节点）
    int root = 0;
    for (int i = 1; i <= n; i++) {
      if (!appear[i]) {
        root = i;
        break;
      }
    }
    // 计算满二叉树节点数目
    int ans = 0;
    GetNodeInfo(&tree_node[root], ans);
    cout << ans << endl;
  }
}

/*
5
2 3
4 5
-1 -1
-1 -1
-1 -1
*/
CPP

第二题


三个数最大值减最小值=1，使用map记录数组与出现次数，对每个数字处理number与number+1的次数问题，注意结果可能超过int表示范围，需用long long存储

按记忆打的，不一定对

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
  int n;
  while (cin >> n) {
    map<int, ll> ma;  // 数字-出现次数
    for (int i = 0; i < n; i++) {
      int x;
      cin >> x;
      ma[x]++;
    }
    ll ans = 0;
    for (auto& [number, times] : ma) {
      if (ma.count(number + 1) > 0) {  // 考虑number-number+1的组合
        ll another_times = ma[number + 1];
        if (times > 1) {  // 选择两个number 一个number+1
          ans += times * (times - 1) / 2 * another_times;
        }
        if (another_times > 1) {  // 选择两个number+1 一个number
          ans += another_times * (another_times - 1) / 2 * times;
        }
      }
    }
    cout << ans << endl;
  }
}
CPP

第三题


思路
由于是第三题，所以我默认它很难，我就直接使用暴力回溯写了一遍

1
2
3
4
5
6
7
8
9
数组排序
dfs:
	0: 达到终止条件，计算极差
	1: 将数组首部数据乘2
	2: dfs
	3: 还原数组
	4: 将数组尾部数据除2
	5: dfs
	6: 还原数组
CPP

细想一下可以知道，这根本不需要dfs，只需要for循环即可，不过我养成了思维定式，第三题一律暴力回溯

1
2
3
4
5
6
7
8
9
前面i个数据乘2，后面k-i个数据除2
for(int i=0;i<=k;i++){
	for(int j=0;j<i;j++){
		首部数据乘2
	}
	for(int j=0;j<k-i;j++){
		尾部数据除2
	}
}
CPP

另外我使用全排列写了一遍，不再使用以上的策略，直接所有情况枚举一遍

1
2
3
4
5
6
7
8
9
10
for(int i=start;i<vec.size();i++){
	swap(vec[i],vec[start];
	当前数字乘2
	dfs
	还原数字
	当前数字除2
	dfs
	还原数字
	swap(vec[i],vec[start];
}
CPP

最终我的解法都以超时结束，不知道用for循环实现可以得多少分

2023-3-16 蚂蚁机试

题目链接：「技术笔试」蚂蚁金服 2023-03-16
最终得分2.3分，第三题写了40分钟只得了30分，一直没找到bug

第一题 整数抽取

1e14 范围以内的一个正整数，将其每一数位上的奇数和偶数分别抽取出来组成两个新的数字，求这两差的绝对值。
思路
先将数字压入栈，然后计算奇数 偶数大小，上面的题解使用的是字符串存储数字，省去了压栈这一步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <bits/stdc++.h>
using namespace std;

using ll = long long;

ll GetValue(stack<int>& s) {  // 计算数字大小
  ll ans = 0;
  while (!s.empty()) {
    ans = ans * 10 + s.top();
    s.pop();
  }
  return ans;
}
int main() {
  ll n;
  while (cin >> n) {
    stack<int> one, two;
    while (n != 0) {
      int num = n % 10;
      if (num % 2 == 0) {  // 偶数
        two.emplace(num);
      } else if (num % 2 == 1) {  // 奇数
        one.emplace(num);
      }
      n /= 10;
    }
    cout << abs(GetValue(one) - GetValue(two)) << endl;
  }
}
CPP

第二题 组装电脑

n 组零件，每组零件有若干种，每一种有一个价格和性能。你需要从每组里面选出一种零件，使得总价格不超过 x，并且性能总和最大。
n <= 40, 所有零件的种类数不超过 40，其他数值 1e9。
思路
首先简单判断一下是否能完成组装，不能就直接返回，能的话就使用dfs穷举所有可能，找到最大性能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <bits/stdc++.h>
using namespace std;

using ll = long long;  // 全部使用long long存储，避免溢出
const ll kInf = 1 << 30;
void dfs(const vector<vector<pair<ll, ll>>>& vec, ll cur_index, ll cur_x, ll cur_v, ll& max_v) {
  if (cur_index >= vec.size()) {  // 选完所有零件，计算最大性能
    max_v = max(max_v, cur_v);
    return;
  }
  for (auto [a, v] : vec[cur_index]) {
    if (cur_x >= a) {  // 选择可选的零件
      dfs(vec, cur_index + 1, cur_x - a, cur_v + v, max_v);
    }
  }
}
int main() {
  ll n, x;
  while (cin >> n >> x) {
    vector<vector<pair<ll, ll>>> arr(n);
    ll min_x = 0;  // 最小零件价格总和
    for (ll i = 0; i < n; i++) {
      ll m, a, v;
      ll min_a = kInf;
      cin >> m;
      arr[i] = vector<pair<ll, ll>>(m);
      for (ll j = 0; j < m; j++) {
        cin >> arr[i][j].first;
        min_a = min(min_a, arr[i][j].first);  // 记录该类型零件最小价格
      }
      for (ll j = 0; j < m; j++) {
        cin >> arr[i][j].second;
      }
      min_x += min_a;
    }
    if (x < min_x) {  // 无法完成组装
      cout << -1 << endl;
      continue;
    }
    ll ans = 0;
    dfs(arr, 0, x, 0, ans);  // 计算最大零件价值和
    cout << ans << endl;
  }
}
CPP

第三题 带传送阵的矩阵游离

n 行 m 列的矩阵，每个位置上有一个元素。你可以上下左右行走，代价是前后两个位置元素值差的绝对值。另外，你最多可以使用一次传送阵（只能从一个数跳到另外一个相同的树），求从走上角走到右下角最少需要多少时间。
1 <= n, m <= 500, 1 <= aij <= 1e9。

思路
刚开始想了想，如果用dfs，应该能得30-60分，但当时时间也挺多的，就想完全通过。方法就是计算各点到起点的距离，计算各点到终点的距离，设使用传送阵的起始点为x，终点为y，最终的路径长度即为dist_form_start[x] + 0（传送阵代价） + dist_to_end[y]，可惜代码有bug，只得了30分，我觉得我思路是没问题的

以下为有bug的版本，先计算两个最短距离，然后使用传送计算最终距离

额，好像优先队列没设置为小顶堆，有点尴尬，这样都能得30分，运气不错
设置方式为

1
2
3
4
5
6
// 自带的比较函数
priority_queue<TP, vector<TP>, greater<TP>> q;
// 自定义比较函数
auto cmp = [](const pair<int, int>& p1, const pair<int, int>& p2) -> bool { return p1.second > p2.second; };
priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> qu(cmp);

CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
const ll kInf = 0xfffffffffffff;
int main() {
  ll n, m;
  while (cin >> n >> m) {
    vector<vector<ll>> arr(n, vector<ll>(m));
    unordered_map<ll, vector<pair<ll, ll>>> ma;
    for (ll i = 0; i < n; i++) {
      for (ll j = 0; j < m; j++) {
        cin >> arr[i][j];
      }
    }

    for (ll i = 0; i < n; i++) {
      for (ll j = 0; j < m; j++) {
        if (ma.count(arr[i][j]) == 0) {
          vector<pair<ll, ll>> tmp;
          tmp.emplace_back(i, j);
          ma[arr[i][j]] = tmp;
        } else {
          ma[arr[i][j]].emplace_back(i, j);
        }
      }
    }
    vector<vector<ll>> dist1(n, vector<ll>(m, kInf));
    vector<vector<bool>> visit1(n, vector<bool>(m, false));
    priority_queue<tuple<ll, ll, ll>> qu;
    dist1[0][0] = 0;
    qu.emplace(0, 0, 0);
    while (!qu.empty()) {
      auto [from_start, i, j] = qu.top();
      qu.pop();
      if (visit1[i][j]) {
        continue;
      }
      visit1[i][j] = true;

      if (i + 1 < n) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i + 1][j]);
        if (dist1[i + 1][j] > cur_dist) {
          dist1[i + 1][j] = cur_dist;
          qu.emplace(cur_dist, i + 1, j);
        }
      }
      if (i - 1 >= 0) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i - 1][j]);
        if (dist1[i - 1][j] > cur_dist) {
          dist1[i - 1][j] = cur_dist;
          qu.emplace(cur_dist, i - 1, j);
        }
      }
      if (j + 1 < m) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i][j + 1]);
        if (dist1[i][j + 1] > cur_dist) {
          dist1[i][j + 1] = cur_dist;
          qu.emplace(cur_dist, i, j + 1);
        }
      }
      if (j - 1 >= 0) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i][j - 1]);
        if (dist1[i][j - 1] > cur_dist) {
          dist1[i][j - 1] = cur_dist;
          qu.emplace(cur_dist, i, j - 1);
        }
      }
    }
    vector<vector<ll>> dist2(n, vector<ll>(m, kInf));
    vector<vector<bool>> visit2(n, vector<bool>(m, false));
    dist2[n - 1][m - 1] = 0;
    qu.emplace(0, n - 1, m - 1);
    while (!qu.empty()) {
      auto [from_start, i, j] = qu.top();
      qu.pop();
      if (visit2[i][j]) {
        continue;
      }
      visit2[i][j] = true;

      if (i + 1 < n) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i + 1][j]);
        if (dist2[i + 1][j] > cur_dist) {
          dist2[i + 1][j] = cur_dist;
          qu.emplace(cur_dist, i + 1, j);
        }
      }
      if (i - 1 >= 0) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i - 1][j]);
        if (dist2[i - 1][j] > cur_dist) {
          dist2[i - 1][j] = cur_dist;
          qu.emplace(cur_dist, i - 1, j);
        }
      }
      if (j + 1 < m) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i][j + 1]);
        if (dist2[i][j + 1] > cur_dist) {
          dist2[i][j + 1] = cur_dist;
          qu.emplace(cur_dist, i, j + 1);
        }
      }
      if (j - 1 >= 0) {
        ll cur_dist = from_start + abs(arr[i][j] - arr[i][j - 1]);
        if (dist2[i][j - 1] > cur_dist) {
          dist2[i][j - 1] = cur_dist;
          qu.emplace(cur_dist, i, j - 1);
        }
      }
    }
    vector<vector<ll>> dist(n, vector<ll>(m, kInf));
    ll min_dist = kInf;
    for (ll i = 0; i < n; i++) {
      for (ll j = 0; j < m; j++) {
        auto vec = ma[arr[i][j]];
        for (auto [xi, xj] : vec) {
          if (dist1[i][j] != kInf && dist2[xi][xj] != kInf) {
            dist[i][j] = min(dist[i][j], dist1[i][j] + dist2[xi][xj]);
          }
        }
        min_dist = min(min_dist, dist[i][j]);
      }
    }
    cout << min_dist << endl;
  }
}
CPP

相比之下，牛客网上的题解就简洁多了，多加一个维度k，对维度同样使用状态转移，更加通用的做法，并且在处理方向上，我还是用习惯的方法，对每个方向进行枚举，而题解中则使用dir数组进行统一处理，既方便又不容易出错，map赋值时我还对是否存在该值进行分类讨论，实际上是不需要的，如果不存在map会先设置默认值而后进行更新

1
2
3
4
5
6
7
8
for (int i = 0; i < 4; i++) {
    int nx = x + dir[i][0], ny = y + dir[i][1];
    if (nx < 0 || nx >= n || ny < 0 || ny >= m || v[nx][ny][z] == 1) continue;
    if (d[nx][ny][z] > dist + abs(a[x][y] - a[nx][ny])) {
        d[nx][ny][z] = dist + abs(a[x][y] - a[nx][ny]);
        q.push({d[nx][ny][z], nx, ny, z});
    }
}
CPP

2023-03-19 米哈游机试

题目链接：全网首发-真题分享|3月19日米哈游校招研发岗三道题
参考题解：
米哈游笔试题目思路（客户端卷）
米哈游后端笔试题解

第一题

米小游拿到了一个矩阵，矩阵上有一格有一个颜色，为红色( R )。绿色( G )和蓝色( B )这三种颜色的一种。然而米小游是蓝绿色盲，她无法分游蓝色和绿色，所以在米小游眼里看来，这个矩阵只有两种颜色，因为蓝色和绿色在她眼里是一种颜色。米小游会把相同颜色的部分看成是一个连通块。请注意，这里的连通划是上下左右四连通的。由于色盲的原因，米小游自己看到的连通块数量可能比真实的连通块数量少。你可以帮米小游计算连通块少了多少吗？

思路
看到连通分量，就自然而然想用并查集实现，实际上只需要连接两个方向的节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <bits/stdc++.h>
using namespace std;

class UnionFind {  // 并查集类
 public:
  UnionFind(int size) {  // 初始化
    data_ = vector<int>(size);
    for (int i = 0; i < size; i++) {
      data_[i] = i;
    }
  }

  int Find(int k) {  // 查找
    if (data_[k] == k) {
      return k;
    }
    data_[k] = Find(data_[k]);
    return data_[k];
  }
  void Union(int p, int q) {  // 合并
    int rootp = Find(p);
    int rootq = Find(q);
    data_[rootp] = rootq;
  }
  int Size() {  // 连通分量数目
    int size = 0;
    for (int i = 0; i < data_.size(); i++) {
      if (data_[i] == i) {
        size++;
      }
    }
    return size;
  }

 private:
  vector<int> data_;
};

int main() {
  int n, m;
  int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
  while (cin >> n >> m) {
    vector<vector<char>> arr(n, vector<char>(m));
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        cin >> arr[i][j];
      }
    }
    // 真实情况连通数量
    UnionFind uf1(n * m);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        for (int k = 0; k < 4; k++) {
          int nx = i + dir[k][0];
          int ny = j + dir[k][1];
          if (nx >= 0 && nx < n && ny >= 0 && ny < m && arr[i][j] == arr[nx][ny]) {
            uf1.Union(i * m + j, nx * m + ny);
          }
        }
      }
    }
    int size1 = uf1.Size();
    // 视角连通分量数量
    UnionFind uf2(n * m);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        for (int k = 0; k < 4; k++) {
          int nx = i + dir[k][0];
          int ny = j + dir[k][1];
          if (nx >= 0 && nx < n && ny >= 0 && ny < m && ((arr[i][j] == 'R') == (arr[nx][ny] == 'R'))) {
            uf2.Union(i * m + j, nx * m + ny);
          }
        }
      }
    }
    int size2 = uf2.Size();
    cout << size1 - size2 << endl;
  }
}
CPP

dfs的解法如下，比并查集少一点代码，写起来快点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<vector<char>>& vec, vector<vector<bool>>& visit, int x, int y, char target, int n, int m) {
  visit[x][y] = true;  // 设置成已访问
  static int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
  for (int k = 0; k < 4; k++) {  // 遍历四个方向
    int nx = x + dir[k][0];
    int ny = y + dir[k][1];
    if (nx >= 0 && nx < n && ny >= 0 && ny < m && visit[nx][ny] == false && vec[nx][ny] == target) {  // 坐标合法，未访问过，为目标值
      dfs(vec, visit, nx, ny, target, n, m);
    }
  }
}
int main() {
  int n, m;
  while (cin >> n >> m) {
    vector<vector<char>> arr(n, vector<char>(m));
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        cin >> arr[i][j];
      }
    }
    vector<vector<bool>> visit1(n, vector<bool>(m, false));
    int cnt1 = 0;  // 连通分量数目
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        if (visit1[i][j] == false) {
          cnt1++;
          dfs(arr, visit1, i, j, arr[i][j], n, m);
        }
      }
    }
    // 将蓝色改成绿色
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        if (arr[i][j] == 'B') {
          arr[i][j] = 'G';
        }
      }
    }
    vector<vector<bool>> visit2(n, vector<bool>(m, false));
    int cnt2 = 0;  // 连通分量数目
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        if (visit2[i][j] == false) {
          cnt2++;
          dfs(arr, visit2, i, j, arr[i][j], n, m);
        }
      }
    }
    cout << cnt1 << " " << cnt2 << endl;
    cout << cnt1 - cnt2 << endl;
  }
}
CPP

第二题

米小游拿到了一个字符串 s 。她可以进行任意次以下两种操作：
1 删除 s 的一个 “mhy” 子序列。
2 添加一个 “mhy” 子序列在 s 上。
例如，给定 s 为 “mhbdy” ，米小游进行一次操作后可以使 s 变成 “bd” ，或者变成 “mhmbhdyy” 。
米小游想知道，经过若干次操作后 s 是否可以变成 t ？
注：子序列在原串中的顺序也是从左到右，但可以不连续。

思路
觉得写不出来，就直接进行骗分策略，看了别人的题解才发现解法很简单，最重要的是想到mhy三个字母的序列不重要

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <bits/stdc++.h>
using namespace std;

bool Check(string& s, string& t) {
  vector<int> num1(26, 0);
  vector<int> num2(26, 0);
  // 统计字符串各字母次数
  for (char c : s) {
    num1[c - 'a']++;
  }
  for (char c : t) {
    num2[c - 'a']++;
  }
  int m, h, y;  // 记录mhy字母次数差值
  for (int i = 0; i < 26; i++) {
    if (i == 'm' - 'a') {
      m = num1[i] - num2[i];
    } else if (i == 'h' - 'a') {
      h = num1[i] - num2[i];
    } else if (i == 'y' - 'a') {
      y = num1[i] - num2[i];
    } else if (num1[i] != num2[i]) {  // 其他字母数量不相等，不能转换
      return false;
    }
  }
  return (m == h) && (h == y);  // 差值相等则可以进行转换
}
int main() {
  int q;
  cin >> q;
  for (int i = 0; i < q; i++) {
    string s, t;
    cin >> s >> t;
    if (Check(s, t)) {
      cout << "Yes" << endl;
    } else {
      cout << "No" << endl;
    }
  }
}
CPP

第三题


思路：
我的思路与题解一样，只不过我少了倍数预处理的一步，直接两层for循环找到因数更新dp数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
const int mod = 1e9 + 7;
const int kMax = 1e6 + 1;
vector<bool> visit(kMax, false);   // visit[i]: 数字i是否出现
vector<vector<int>> factor(kMax);  // factor[i]: i的各个因数
vector<ll> dp(kMax, 0);            // dp[i]: 以i结尾的数字集合数目
int main() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    visit[a[i]] = true;
  }
  sort(a.begin(), a.end());  // 数字排序
  int max_n = a[n - 1];      // 最大数字
  // 预处理倍数关系
  for (int i = 1; i <= max_n; i++) {
    if (visit[i] == false) {
      continue;
    }
    for (int j = i + i; j <= max_n; j += i) {
      if (visit[j] == true) {
        factor[j].emplace_back(i);  // i为j的因数
      }
    }
  }
  for (int i = 1; i < n; i++) {
    for (int num : factor[a[i]]) {
      dp[a[i]] += dp[num] + 1;  // a[i]可以和num的数字集合全部组合一遍，最后加上{num,a[i]}
    }
    dp[a[i]] %= mod;
  }
  ll ans = 0;
  for (int i = 1; i < n; i++) {
    ans += dp[a[i]];
  }
  ans %= mod;
  cout << ans << endl;
}
CPP

2023-03-23 腾讯音乐笔试

题目：3.23 腾讯音乐 暑期 实习 技术类 笔试
中途肚子痛，提前半小时交卷了，第一题写了一半，第二题dfs骗了几十分，第三题签到

笔试或面试前千万别吃坏肚子

第一题


这个问题可以分解成两个子问题：
1 通过层序遍历得到奇偶层节点个数
2 假设奇数层节点个数为k，解决是否能从[1,n]中选择k个数，总和为target问题

若1-n总和为偶数，则target为sum/2，若为奇数，则target为sum/2或sum/2+1

代码片段如下：（不一定对）
第一步：层序遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
TreeNode* fun(TreeNode* root) {
  queue<Info> qu;
  int one = 0;                 // 奇数节点数
  int two = 0;                 // 偶数节点数
  stack<TreeNode*> one_stack;  // 奇数节点栈
  stack<TreeNode*> two_stack;  // 偶数节点栈
  qu.emplace(root, 1);
  while (!qu.empty()) {
    Info info = qu.front();
    TreeNode* node = info.first;
    int level = info.second;
    qu.pop();
    if (level % 2 == 1) {
      one++;
      one_stack.emplace(node);
    } else {
      two++;
      two_stack.emplace(node);
    }
    if (node->left != nullptr) {  // 将左子树节点压入队列
      qu.emplace(node->left, level + 1);
    }
    if (node->right != nullptr) {  // 将右子树节点压入队列
      qu.emplace(node->right, level + 1);
    }
  }
}
CPP

第二步：选择k个数总和为target
双指针法求得可能结果

刚开始左区域最大，右区域为空，此时sum最小，而后一直将left right向左移动，增大sum，直至sum>target

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <bits/stdc++.h>
using namespace std;

vector<int> FindSuitNumber(int n, int k, int target) {  // [1,n]中选择k个数，总和为target
  // 等差数列求和公式：Sn = n * (a1 + an) / 2
  int min_sum = k * (1 + k) / 2;
  int max_sum = k * (n - k + 1 + n) / 2;
  if (target < min_sum || target > max_sum) {
    // printf("target %d: no suit number\n", target);
    return {};
  }
  // 如果target属于[min_sum,max_sum]，则target一定能取到
  vector<int> seq(n);
  for (int i = 0; i < n; i++) {
    seq[i] = i + 1;
  }
  // 最后数据构成：0...left  extra_num right+1...n-1
  int left = k - 1;
  int right = n - 1;
  int sum = min_sum;
  int extra_num = -1;
  while (left >= 0) {
    int sub = seq[right] - seq[left];
    if (sum + sub < target) {  // 小于目标值，将右侧元素加入集合
      left--;
      right--;
      sum += sub;
    } else {
      extra_num = seq[left] + target - sum;
      left--;
      break;
    }
  }

  vector<int> ans;
  for (int i = 0; i <= left; i++) {
    ans.emplace_back(seq[i]);
  }

  ans.emplace_back(extra_num);

  for (int i = right + 1; i < n; i++) {
    ans.emplace_back(seq[i]);
  }
  // 校验结果
  int result = accumulate(ans.begin(), ans.end(), 0);
  if (result != target) {  // 总和不为target
    printf("target: %d result: %d\n", target, result);
  }
  if (ans.size() != k) {  // 数量错误
    printf("wrong ans size: %d", ans.size());
  }
  set<int> se;
  for (int num : ans) {
    if (num < 1 || num > n) {  // 数字超出范围
      printf("wrong value: %d\n", num);
    }
    if (se.count(num) > 0) {  // 重复数字
      printf("repeat value: %d\n", num);
    }
    se.emplace(num);
  }

  return ans;
}

int main() {
  for (int i = 0; i < 10000; i++) {
    for (int j = 1; j <= 100; j++) {
      FindSuitNumber(100, j, i);
    }
  }
}
CPP

第二题


算法实现中为避免函数参数过多，可以将公有的数据结构放在类成员中，且没必要遵循命名规范（类成员名后加_），类成员的设置应该在具体实现前想好。

第二题看别人说是最大值最小化问题，使用二分+贪心的方法解决，但没看到啥具体实现
（二分答案，贪心验证答案是否符合，符合就再缩小一点答案，不符合就扩大一点 ）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <bits/stdc++.h>
using namespace std;
class Solution {
 public:
  int getValue(int start, int end) {  // 计算str[str,end)的metric，种类x长度
    vector<int> num(26, 0);           // 字符出现次数
    for (int i = 0; i < 26; i++) {
      num[i] = char_num_[end][i] - char_num_[start][i];
    }
    int diff = 0;  // 不同字符数目
    for (int i = 0; i < 26; i++) {
      if (num[i] > 0) {
        diff++;
      }
    }
    return diff * (end - start);
  }
  int computeMaxValue() {
    int max_value = 0;  // 计算最大metric
    // 分割位置集合[0,seq0,seq1,..seqk-1,length]
    for (int i = 0; i < k_; i++) {
      if (i == k_ - 1) {
        max_value = max(max_value, getValue(seq_[i], length_));  // 最后一个切割位置，与数组末尾配对
      } else {
        max_value = max(max_value, getValue(seq_[i], seq_[i + 1]));
      }
    }
    return max_value;
  }
  void dfs(int index, int& max_value) {
    if (index == k_) {
      max_value = min(max_value, computeMaxValue());  // 记录最小的最大metric
      return;
    }
    for (int i = index; i < seq_.size(); i++) {  // 全排列，但seq[i]>seq[i-1]
      if (seq_[i] > seq_[index - 1]) {
        swap(seq_[index], seq_[i]);
        dfs(index + 1, max_value);
        swap(seq_[index], seq_[i]);
      }
    }
  }
  int getMaxValue(string str, int k) {
    k_ = k;
    length_ = str.length();
    char_num_ = vector<vector<int>>(str.length() + 1, vector<int>(26, 0));  // char_num_[i]表示s[i]前的各字符出现次数，用于快速计算区间字符种类
    for (int i = 0; i < str.length(); i++) {
      char_num_[i + 1] = char_num_[i];
      char_num_[i + 1][str[i] - 'a']++;
    }

    if (k == 1) {
      return getValue(0, str.length());  // 不需要分割，直接计算metric
    }
    seq_ = vector<int>(str.length());
    for (int i = 0; i < str.length(); i++) {
      seq_[i] = i;
    }
    int ans = 1 << 30;
    dfs(1, ans);  // 第一位一定为0，数组开始索引为1
    return ans;
  }

 private:
  vector<vector<int>> char_num_;
  vector<int> seq_;
  int k_;
  int length_;
};
int main() {
  Solution solution;
  solution.getMaxValue("ababbbb", 2);
}
CPP

第三题

签到题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <bits/stdc++.h>
using namespace std;
class Solution {
 public:
  int getCnt(string str) {
    int ans = 0;
    for (int i = 0; i < str.length() - 1; i++) {
      int sub = abs(str[i] - str[i + 1]);
      if (sub == 'a' - 'A' || sub == 0) {
        ans++;
      }
    }
    return ans;
  }
};
CPP

2023-03-26 腾讯笔试

题目：腾讯笔试记录0326（研发）
就写出了第一第二题，第三题题目有点问题，导致我写了40分钟没得啥分，一直没理解最后一个样例是怎么来的，第四第五题一看就是我不会的题目，随便写了写

第一题 链表操作

链表中相邻节点两两一组，然后相邻两组之间进行交换
类似的题目：25. K 个一组翻转链表
直接将链表节点指针存入数组，便于理解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Solution {
 public:
  ListNode* reorderList(ListNode* head) {
    ListNode virt_head(-1);  // 虚拟头节点
    virt_head.next = head;
    vector<ListNode*> arr;
    ListNode* cur = head;
    while (cur != nullptr) {
      arr.emplace_back(cur);
      cur = cur->next;
    }
    int num = arr.size();
    ListNode* prev = &virt_head;  // 待处理组的前一个节点
    for (int i = 0; i + 3 < num; i += 4) {
      prev->next = arr[i + 2];              // 指向第二组的头节点
      arr[i + 1]->next = arr[i + 3]->next;  // 指向第二组后一个节点
      prev = arr[i + 1];                    // 更新prev节点
      arr[i + 3]->next = arr[i];            // 更新第二组的next为第一组头节点
    }
    if (num % 4 == 3) {  // 剩下3个节点，特殊处理
      prev->next = arr[num - 1];
      arr[num - 2]->next = arr[num - 1]->next;
      arr[num - 1]->next = arr[num - 3];
    }
    return virt_head.next;
  }
};
CPP

第二题 重组字符串

给定N个字符串，每个字符串全部由小写字母组成，且每个字符串的长度最多为8,请你断有多少重组字符串，重组字符串有以下规则：1.从每个字符串里面都抽取1个字母组成。2.新字符串不能有2个相同的字母。请问总共能组成多少个重组字符串。

字符串长度比较小，用dfs暴力枚举即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<string>& strs, int index, string cur_str, set<string>& res) {
  if (index == strs.size()) {  // 加入结果集合
    res.emplace(cur_str);
    return;
  }
  for (char c : strs[index]) {
    if (cur_str.find(c) == string::npos) {  // 无重复字母
      cur_str.push_back(c);                 // 加入字符串
      dfs(strs, index + 1, cur_str, res);   // 遍历下一个字符串
      cur_str.pop_back();                   // 还原
    }
  }
}
int main() {
  int n;
  cin >> n;
  vector<string> strs(n);
  for (int i = 0; i < n; i++) {
    cin >> strs[i];
  }
  set<string> ans;  // 使用set去重
  dfs(strs, 0, "", ans);
  cout << ans.size();
}
CPP

第三题 最小权值排列数组

给定2个整数数组A,B,数组长度都为N,数组B为权值数组，权值数据范国为[0,2],请你构造一个数组C,满足以下条件：
1,长应为N
2.数组元素范国为[1,N],且元素值不能更复，即为N的一个排列
3.如果数组下标i<j，且有B[i]>B[j],那么一定要保证C[i]>C[j]
4数组C与数组A每个元素之差的和的绝对值最小.

按理来说样例的答案应该是98，但样例是104，一直想不出来为什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int kMax = 2 * 10e5 + 1;
vector<int> A(kMax);
vector<int> B(kMax);
int n;
ll ans = 0xffffffffffff;
void dfs(vector<ll>& seq, int index, int one_min, int two_min) {  // one_min 前面1位置的最小值 two_min 前面2位置的最小值
  if (index == n) {
    ll array_abs_sum = 0;  // 差值的绝对值之和
    for (int i = 0; i < n; i++) {
      array_abs_sum += abs(seq[i] - A[i]);
    }
    ans = min(ans, array_abs_sum);
    // 打印样例序列
    if (array_abs_sum == 98) {
      for (int num : seq) {
        cout << num << " ";
      }
      cout << endl;
    }
    return;
  }

  for (int i = index; i < n; i++) {
    if (B[index] == 0) {
      if (seq[i] < one_min && seq[i] < two_min) {  // 需小于1最小值与2最小值
        swap(seq[i], seq[index]);
        dfs(seq, index + 1, one_min, two_min);
        swap(seq[i], seq[index]);
      }
    } else if (B[index] == 1) {
      if (seq[i] < two_min) {  // 需小于2最小值
        int new_one_min = min<ll>(seq[i], one_min);
        swap(seq[i], seq[index]);
        dfs(seq, index + 1, new_one_min, two_min);  // 更新1最小值
        swap(seq[i], seq[index]);
      }
    } else {
      int new_two_min = min<ll>(seq[i], two_min);
      swap(seq[i], seq[index]);
      dfs(seq, index + 1, one_min, new_two_min);  // 更新2最小值
      swap(seq[i], seq[index]);
    }
  }
}
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> A[i];
  }
  for (int i = 0; i < n; i++) {
    cin >> B[i];
  }
  vector<ll> seq(n);  // [1,n]序列
  for (int i = 0; i < n; i++) {
    seq[i] = i + 1;
  }
  dfs(seq, 0, kMax + 1, kMax + 1);
  cout << ans << endl;
}

/*
6
100 2 3 1 5 6
0 1 2 0 2 1
样例答案：104
我的答案：98
6 2 4 1 5 3
98
*/
CPP

2023-03-28 百度笔试

题目链接：3.28百度笔试复盘

图解SQL的inner join、left /right join、 outer join区别

编程题过了2.8道，第三题一直超时，只得了80分

第一题

题目：

签到题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <bits/stdc++.h>
using namespace std;

const int kMod = 1e9 + 7;
using ll = long long;
int main() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  string str;
  cin >> str;
  ll red_sum = 0;   // 红色权值之和
  ll blue_sum = 0;  // 蓝色权值之和
  for (int i = 0; i < n; i++) {
    if (str[i] == 'R') {
      red_sum = (red_sum + a[i]) % kMod;
    } else {
      blue_sum = (blue_sum + a[i]) % kMod;
    }
  }
  ll ans = (red_sum * blue_sum) % kMod;
  cout << ans << endl;
}
CPP

第二题

题目：

标准解法是单调栈，不过我当时没想到，就用数组存从当前位置往右看最大value的索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <bits/stdc++.h>
using namespace std;

int main() {
  string str;
  cin >> str;
  int length = str.length();
  string ans = "0.";
  vector<int> max_see(length);  // 从当前位置往右看最大value的索引
  max_see[length - 1] = length - 1;
  for (int i = length - 2; i >= 2; i--) {
    char next_max_value = str[max_see[i + 1]];
    if (str[i] >= next_max_value) {  // 当前位置比右边最大值大
      max_see[i] = i;
    } else {  // 当前位置比右边最大值小
      max_see[i] = max_see[i + 1];
    }
  }
  for (int i = 2; i < length; i++) {
    ans.push_back(str[max_see[i]]);
    i = max_see[i];
  }
  cout << ans << endl;
}
CPP

第三题

题目：

只得了80分，要么时间超时，要么内存使用过多，可以优化的点在于输入x y时将信息暂存到某一个地方，而后在树遍历的过程中一次性计算所有，而不是每次都遍历x的所有子节点，并与info相加，不过最后没时间了，就没实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <bits/stdc++.h>
using namespace std;
using NumberInfo = pair<int, int>;  // 记录数字中2，5因数的个数
NumberInfo GetInfo(int x) {         // 得到数字2，5因数的个数
  int two = 0, five = 0;
  while (x > 0 && x % 2 == 0) {
    two++;
    x = x / 2;
  }
  while (x > 0 && x % 5 == 0) {
    five++;
    x = x / 5;
  }
  return {two, five};
}

void AddInfo(NumberInfo& p1, NumberInfo p2) {  // 因数个数相加
  p1.first += p2.first;
  p1.second += p2.second;
}

int main() {
  int n, q;
  cin >> n;
  vector<bool> visited(n + 1, false);  // 该节点是否出现
  vector<int> tree(n + 1);             // 使用数组维护树结构
  vector<vector<int>> child(n + 1);    // 节点的子节点（包括自身）
  vector<NumberInfo> num(n + 1);       // 各节点2,5因数个数
  for (int i = 1; i <= n; i++) {
    int a;
    cin >> a;
    num[i] = GetInfo(a);
    child[i].emplace_back(i);
  }
  // 构建树结构，1为根节点
  visited[1] = true;
  tree[1] = 1;
  for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    // 确定哪个为父节点
    if (visited[u]) {
      tree[v] = u;
      visited[v] = true;
    } else {
      tree[u] = v;
      visited[u] = true;
    }
  }
  visited.clear();
  // 计算各节点子节点信息
  for (int i = 2; i <= n; i++) {
    int root = i;
    do {
      root = tree[root];
      child[root].emplace_back(i);
    } while (root != 1);
  }
  cin >> q;
  for (int i = 0; i < q; i++) {
    int x, y;
    cin >> x >> y;
    NumberInfo info = GetInfo(y);
    // 所有子节点信息加上info因数个数
    for (auto node : child[x]) {
      AddInfo(num[node], info);
    }
  }
  // 计算各节点的最终值（因数2与因数5的个数）
  for (int i = 2; i <= n; i++) {
    int root = i;
    do {
      root = tree[root];
      AddInfo(num[root], num[i]);
    } while (root != 1);
  }
  // 计算各节点后缀0的个数（因数2与因数5个数的较小值）
  for (int i = 1; i <= n; i++) {
    cout << min(num[i].first, num[i].second) << " ";
  }
}
CPP

杂项

判断字符串

ali字符串，刚开始忽略了对开头字符是否为Aa的判断，只有3种状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <bits/stdc++.h>
using namespace std;

int main() {
  string str;
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> str;
    int status = 0;      //  状态机转换  0：初始状态 1：遇到Aa 2：遇到lL 3: 遇到iI
    bool error = false;  // 是否发生错误
    for (char c : str) {
      if (status == 0) {
        if (c == 'a' || c == 'A') {  //  状态转换
          status = 1;
        } else {  // 预期之外的值，发生错误
          error = true;
          break;
        }
      } else if (status == 1) {
        if (c == 'l' || c == 'L') {  //  状态转换
          status = 2;
        } else if (c != 'a' && c != 'A') {  // 预期之外的值，发生错误
          error = true;
          break;
        }
      } else if (status == 2) {
        if (c == 'i' || c == 'I') {  //  状态转换
          status = 3;
        } else if (c != 'l' && c != 'L') {  // 预期之外的值，发生错误
          error = true;
          break;
        }
      } else if (status == 3) {
        if (c != 'i' && c != 'I') {  // 预期之外的值，发生错误
          error = true;
          break;
        }
      }
    }
    if (error || status != 3) {  // 发生错误或未遇到i
      cout << "No" << endl;
    } else {
      cout << "Yes" << endl;
    }
  }
}
CPP

01翻转

使用dfs遍历各个翻转可能，加上一点剪枝策略，骗分
正确思路

dfs优化思路

可以使用备忘录的方式减少各个点最大获得价值的重复计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <bits/stdc++.h>
using namespace std;
const int kMax = 10001;
const int kInf = -1 * (1 << 30);
int n;
vector<int> food(kMax);
vector<vector<int>> path(kMax);
vector<int> max_get(kMax, kInf);

// void dfs(int cur_id, int cur_value, int& max_value) {
//   cur_value += food[cur_id];
//   max_value = max(max_value, cur_value);
//   for (int dst_id : path[cur_id]) {
//     dfs(dst_id, cur_value, max_value);
//   }
// }

int dfs(int cur_id, int cur_value) {
  cur_value += food[cur_id];
  int max_value = cur_value;
  for (int dst_id : path[cur_id]) {
    if (max_get[dst_id] == kInf) {
      max_get[dst_id] = dfs(dst_id, cur_value);
    }
    max_value = max(max_value, max_get[dst_id]);
  }
  return max_value;
}

int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    int id, parent_id, value;
    cin >> id >> parent_id >> value;
    food[id] = value;
    if (parent_id != -1) {
      path[parent_id].emplace_back(id);
    }
  }
  int ans = 0;
  for (int id = 0; id < n; id++) {
    int tmp = dfs(id, 0);
    ans = max(ans, tmp);
  }
  cout << ans << endl;
}

/*
7
0 1 8
1 -1 -2
2 1 9
4 0 -2
5 4 3
3 0 -3
6 2 -3
*/
CPP