🏩题目一描述：

LYA 是一名计算机专业的学生,最近她正在学习数据结构中的二叉搜索树。二叉搜索树是一种常用的数据结构,它可以实现快速的查找和插入操作。

现在,LYA 有一个由 $2^n-1$个不同的正整数组成的数列（$1\le n\le 10$,且 n 为整数）。她想用这些数构建一棵平衡的满二叉搜索树。

二叉搜索树满足以下性质：

1. 节点的左子树只包含小于当前节点的数。
2. 节点的右子树只包含大于当前节点的数。
3. 所有左子树和右子树也必须是二叉搜索树。

例如,对于数列 [1,2,3,4,5,6,7],可以构建出如下图所示的满二叉搜索树：

    4/ \2   6/ \ / \
1  3 5  7

现在,给定一个待查找的数,请你帮助 LYA 计算查找该数的路径和结果。

输入格式

第一行包含若干个用空格分隔的正整数,表示给定的数列。

第二行包含一个正整数,表示待查找的数。

输出格式

输出查找的路径和结果。

路径从根节点开始,用 S 表示。查找左子树用 L 表示,查找右子树用 R 表示。查找到结果用 Y 表示,未找到结果用 N 表示。

样例1

输入

2 1 3 7 5 6 4
6

输出

SRY

解释：
从根节点开始,所以路径的第一部分为 S。待查找数为 6 ,大于根节点 4,所以要查找右子树,路径增加 R,正好找到,因此最后增加 Y。最终输出 SRY。

样例2

输入

4 2 1 3 6 5 7
5

输出

SRLY

解释：
从根节点开始,先查找右子树,再查找左子树,最终找到结果 5,因此输出 SRLY。

样例3

输入

1 2 3 4 5 6 7
8

输出

SRRN

解释：
从根节点开始查找,标记 S。待查找数 8 大于根节点 4,所以查找右子树,标记 R。继续查找右子树,标记 R。8 比右子树节点 7 还大,但已经到达叶子节点,没有找到,因此最后标记 N。

数据范围

• $1\le n\le 10$
• 给定的数列中的数互不相同

OJ链接：
https://codefun2000.com/p/P1830

解题思路一：dfs

本题考查二叉搜索树的构建和查找操作。

首先,我们需要根据给定的数列构建一棵平衡的满二叉搜索树。可以按照如下步骤进行：

1. 将数列按照从小到大的顺序排序。
2. 递归地构建左右子树：
   • 如果当前区间为空,则返回空树。
   • 取区间的中点作为根节点。
   • 递归地构建左子树和右子树。

构建完二叉搜索树后,我们再进行查找操作。从根节点开始,比较当前节点的值与待查找的数：

• 如果相等,则查找成功,返回。
• 如果待查找的数小于当前节点的值,则进入左子树查找。
• 如果待查找的数大于当前节点的值,则进入右子树查找。

在查找的过程中,我们需要记录查找的路径。当查找到目标数时,输出查找路径以及查找结果。

arr = list(map(int, input().split()))
arr.sort()
n = len(arr)
target = int(input())def dfs(arr, l, r, target):if l > r:res.append('N')returnmid = (l + r) >> 1if arr[mid] == target:res.append('Y')returnelif arr[mid] > target:if mid - 1 >= l:res.append('L')dfs(arr, l, mid-1, target)else:if mid + 1 <= r:res.append('R')dfs(arr, mid+1, r, target)
res = ['S']
dfs(arr, 0, n-1, target)
print("".join(res))

时间复杂度：O(nlogn)
空间复杂度：O(n)

解题思路二：直接二分查找哇！

nums = list(map(int, input().split()))
target = int(input())
nums.sort()l, r = 0, len(nums) - 1
res = ['S']
while l <= r:mid = (l+r) // 2if nums[mid] == target:res.append('Y')breakelif nums[mid] > target:r = mid - 1res.append('L')else:l = mid + 1res.append('R')
if res[-1] != 'Y':res.append('N')
print(''.join(res))

时间复杂度：O(nlogn)
空间复杂度：O(1)

解题思路三：c++, java

#include <bits/stdc++.h>
using namespace std;const int maxn=1e4+10;
int a[maxn],n;int main(){std::ios::sync_with_stdio(false);while(cin>>a[n]){n++;}n--;int target=a[n];string s="S";int p=(1+n)/2;int l=1,r=n;while(p!=target){if(target<p){r=p-1;p=(l+p-1)/2;s+="L";}else{l=p+1;p=(p+1+r)/2;s+='R';}}s+="Y";cout<<s;return 0;
}
# java
import java.util.Arrays;
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner in = new Scanner(System.in);String[] strings = in.nextLine().split("\\s+");int[] data = new int[strings.length];int target = in.nextInt();for (int i = 0; i < strings.length; i++) {data[i] = Integer.parseInt(strings[i]);data[i] = i + 1;}System.out.print(solutin(data, target));}private static String solutin(int[] data, int target) {StringBuilder sb = new StringBuilder();if (data != null) {sb.append("S");}int left = 0, right = data.length - 1;int mid = (left + right) / 2;while (left <= right) {if (data[mid] == target) {sb.append("Y");return sb.toString();}else if (data[mid] > target) {sb.append("L");right = mid - 1;mid = (left + right) / 2;}else {sb.append("R");left = mid + 1;mid = (left + right) / 2;}}String temp = sb.toString();return temp.substring(0, temp.length() - 1) + "N";}
}

时间复杂度：O(n)
空间复杂度：O(1)

💒题目二描述：球员能力评估

K教练正在对足球队的 n 名球员进行射门能力评估。评估共进行 m 次训练,每次训练时,若球员射门得分则记为1,否则记为0。现在K教练需要根据以下规则对球员进行排名:

1. 进球总数较多的球员排名靠前。
2. 如果进球总数相同,则最长连续进球次数较多的球员排名靠前。
3. 如果最长连续进球次数也相同,则第一次未进球的训练序号较大的球员排名靠前。如果第一次未进球的训练序号也相同,则比较第二次、第三次……直到比较出结果。
4. 如果按照前三条规则仍然无法区分排名,则编号较小的球员排名靠前。
   请你帮助K教练生成一个球员排名。

输入格式
第一行包含两个正整数 n 和 m , 表示参与评估的球员数量和训练次数,球员编号从1到 n 。

第二行包含 n 个空格分隔的长度为 m 的字符串,第 i 个字符串表示编号为 i 的球员在这 m 次训练中的进球记录。

输出格式
输出一行,包含 n 个空格分隔的正整数,表示球员编号按照射门能力从高到低排列的结果。

数据范围
$1\le n\le 1000$
$1\le m\le 1000$

样例一

输入

4 5
11100 00111 10111 01111

输出

4 3 1 2

解释

4个队员，射门训练5次，队员3和4进球数均为4个，比队员1H和2的3个更多，队员3连续进球故最多一次为3个，而队员4最大为4。因此队员4射门能力强于队员3，另外队员2比队员1先丢球，因此队员1射门能力强于队员2，顺序为4 3 1 2。

样例二

输入

2 10
1011100111 1011101101

输出

2 1

解释

2个队员，射门训练10次，两个队员的进球总数均为7个，连续进球最多的均为3个，且第前两次丢球顺序均为第2次和第6次训练射门，而队员2第三次丢球为第9次训练，队员1为第7次训练，因此队员2的射门能力强于队员1，顺序为2 1

OJ链接：
https://codefun2000.com/p/P1831

解题思路一：元组排序

本题的关键是根据题目描述的规则对球员进行排序。我们可以按照以下思路解决:

1. 统计每个球员的进球总数和最长连续进球次数。
2. 记录每个球员第一次、第二次、第三次……未进球的训练序号。
3. 按照题目规则,以进球总数为第一关键字,最长连续进球次数为第二关键字,未进球训练序号为第三关键字,球员编号为第四关键字,对球员进行降序排序。
4. 输出排序后的球员编号。

在实现时,我们可以使用一个长度为 n 的数组,数组的每个元素是一个四元组(cnt, maxCnt, rec, id),分别表示球员的进球总数、最长连续进球次数、未进球训练序号和球员编号。然后按照题目规则对这个数组进行排序即可。

n, m = map(int, input().split())
rec = list(map(str, input().split()))player = []
for i, r in enumerate(rec):cnt = r.count('1')maxCnt = max(map(len, r.split('0')))missrec = ''.join(['0' if c == '1' else '1' for c in r])player.append((-cnt, -maxCnt, missrec, i+1))player.sort()
print(*[p[3] for p in player])

时间复杂度：O(nlogn)
空间复杂度：O(n)

解题思路二：排序

n, m = map(int, input().split())
lst = input().split()one = [0] * n
con = [0] * n
zero = [[] for _ in range(n)]for i in range(n):s = lst[i]for j in range(m):if s[j] == '1':one[i] += 1else:zero[i].append(j)j = 0while j < m:if s[j] == '0':j += 1continuek = j + 1while k < m and s[k] == '1':k += 1con[i] = max(con[i], k - j)j = ka = list(range(n))
a.sort(key=lambda x: (-one[x], -con[x], [-z for z in zero[x]], x))print(*[x + 1 for x in a])

时间复杂度：O(nlogn)
空间复杂度：O(n)

解题思路三：c++, java

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt(), m = sc.nextInt();String[] records = new String[n];for (int i = 0; i < n; i++) {records[i] = sc.next();}Integer[][] players = new Integer[n][4];for (int i = 0; i < n; i++) {String record = records[i];int cnt = record.replaceAll("0", "").length();int maxCnt = Arrays.stream(record.split("0")).mapToInt(String::length).max().getAsInt();String missRecord = record.replaceAll("1", "2").replaceAll("0", "1").replaceAll("2", "0");players[i] = new Integer[]{-cnt, -maxCnt, Integer.parseInt(missRecord), i + 1};}Arrays.sort(players, Comparator.<Integer[]>comparingInt(p -> p[0]).thenComparingInt(p -> p[1]).thenComparingInt(p -> p[2]).thenComparingInt(p -> p[3]));for (Integer[] player : players) {System.out.print(player[3] + " ");}}
}# c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>using namespace std;bool cmp(vector<int> a, vector<int> b) {if (a[0] != b[0]) return a[0] > b[0];if (a[1] != b[1]) return a[1] > b[1];if (a[2] != b[2]) return a[2] < b[2];return a[3] < b[3];
}int main() {int n, m;cin >> n >> m;vector<vector<int>> players(n, vector<int>(4));for (int i = 0; i < n; i++) {string record;cin >> record;int cnt = 0, maxCnt = 0, curCnt = 0;for (char c : record) {if (c == '1') {cnt++;curCnt++;maxCnt = max(maxCnt, curCnt);} else {curCnt = 0;}}string missRecord = record;replace(missRecord.begin(), missRecord.end(), '1', '2');replace(missRecord.begin(), missRecord.end(), '0', '1');replace(missRecord.begin(), missRecord.end(), '2', '0');players[i] = {cnt, maxCnt, stoi(missRecord), i + 1};}sort(players.begin(), players.end(), cmp);for (auto player : players) {cout << player[3] << " ";}return 0;
}

时间复杂度：O(nlogn)
空间复杂度：O(n)

🏨题目三描述：

K小姐是一名软件工程师,她正在对公司的 n 个微服务进行调用情况分析。这些微服务使用 0 到 n − 1 的整数进行编号。

K小姐得到了一个长度为 n 的数组 edges,其中 edges[i] 表示存在一个从微服务 i 到微服务 edges[i] 的调用关系。

如果多个微服务形成了一个环,我们称之为一个微服务群组。对于一个微服务群组,我们定义:

• L 表示该群组内所有微服务的数量。
• V 表示能够调用到该群组内微服务的微服务数量。
• 该群组的内聚值 H=L−V。

已知给定的调用关系数据中至少存在一个微服务群组,请你计算所有群组的内聚值,并按照以下规则对它们进行排序:

1. 按照内聚值 H 从大到小排序。
2. 如果内聚值相同,则按照群组内最大编号从小到大排序。

最后,请输出排序后的第一个微服务群组,要求从群组内编号最小的微服务开始,按照调用关系的顺序输出其中所有微服务的编号。

输入格式
第一行包含一个正整数 n ,表示微服务的数量。
第二行包含 n 个整数,表示数组 edges,相邻整数之间用空格分隔。其中 edges[i] 表示存在一个从微服务 i 到微服务 edges[i] 的调用关系。

输出格式
输出一行整数,表示内聚值最大的微服务群组,其中微服务编号按照调用关系顺序输出,起始编号为群组内最小编号。相邻整数之间用空格分隔。

数据范围

• $2\le n\le 10^5$
• $0\le edges[i]\le n-1$
• $edges[i]\ne i$

样例一

输入

4
3 3 0 2

输出

0 3 2

解释

0，3，2组成了微服务群组 (环)a，他的L值为3，对于a来说，只有编号为1的1个微服务可以访问到a，因此a的为1答案输出微服务群组为0 3 2

样例二

输入

12
2 6 10 1 6 0 3 0 5 4 5 8

输出

0 2 10 5

解释

1，6，3组成了微服务群组(环) a1，L1值为3，编号为4、9的2个微服务可以访问到a1，因此√1值为2，H1为L1V1 =1;

0，2，10，5组成了微服务群组 (环) a2，L2值为4，编号为7、8、11的3个微服务可以访问到2，因此v2值为3，H2为L2-V2=1；

先对比H值，H1=H2，H值相等;

再对比环中序号最大值，a1中最大数为6。a2中最大数为10，a2排前面，因此输出答案为:0 2 10 5

OJ链接：
https://codefun2000.com/p/P1832

解题思路一：

from collections import defaultdictdef dfs(u):global cntcnt += 1group.append(u)visit[u] = Trueif visit[edges[u]]:if edges[u] in group:idx = group.index(edges[u])size = len(group) - idxconnect = sum(indegree[v] for v in group[idx:])groups.append((-size + connect, -max(group), group[idx:]))else:dfs(edges[u])n = int(input())
edges = list(map(int, input().split()))adj = defaultdict(list)
indegree = [0] * n
for i, v in enumerate(edges):adj[v].append(i)indegree[i] += 1groups = []
visit = [False] * n
for i in range(n):if not visit[i]:cnt = 0group = []dfs(i)groups.sort()
ans = groups[0][2]
start = min(ans)
idx = ans.index(start)print(*(ans[idx:] + ans[:idx]))

时间复杂度：O(n)
空间复杂度：O(n)

解题思路二：c++

#include <bits/stdc++.h>using namespace std;const int N = 1e5 + 1;
int adj[N];
int dfn[N], low[N], dfncnt = 0, scc[N], siz[N], scccnt = 0;bool in_stk[N];
stack<int> s;
int maxn[N], minn[N]; // 记录环上（一个scc就是一个环）最大和最小编号节点void dfs(int u) {dfn[u] = low[u] = ++dfncnt;s.push(u);in_stk[u] = true;int v = adj[u];if (!dfn[v]) {dfs(v);low[u] = min(low[u], low[v]);} else if (in_stk[v]) {low[u] = min(low[u], dfn[v]);}// 事实上，一个scc里的任何一个点都可以作为这个scc的dfs树根// 因此在一个scc内部时，用任何一种遍历顺序都可以if (dfn[u] == low[u]) {int y;do {y = s.top();scc[y] = scccnt;++siz[scccnt];s.pop();in_stk[y] = false;maxn[scccnt] = max(maxn[scccnt], y);minn[scccnt] = min(minn[scccnt], y);} while (y != u); // 由于u一定在栈里，最后一次pop栈顶一定有y == u++scccnt;}// dfs结束时从不pop堆栈// 这样当dfs递归调用回到dfs树的根时，堆栈中会保留这个scc的所有节点
}int main() {int n;cin >> n;// int adj[n];for (int i = 0; i < n; ++i) {cin >> adj[i];}// tarjan scc（求强连通分量）// int dfn[n], low[n], dfncnt = 0, scc[n], siz[n], scccnt = 0;memset(dfn, 0, sizeof dfn);memset(siz, 0, sizeof siz);// bool in_stk[n];memset(in_stk, 0, sizeof in_stk);// stack<int> s;// int maxn[n], minn[n]; // 记录环上（一个scc就是一个环）最大和最小编号节点memset(maxn, 0, sizeof maxn);memset(minn, 0x3f, sizeof minn);// 为什么tarjan只需要跑一遍loop dfs// 假如有两个scc，scc1 -> scc2// 普通dfs无法正确求出scc的原因是：如果从scc1的点开始dfs，那么dfs会搜索到scc2// 但事实上scc2里的点是无法回到scc1的，它们不是同一个scc// 但在使用tarjan算法时，即使从scc1开始dfs，搜索到了scc2// scc2的点最多也只能回溯到开始进入scc2的起始点（并且那个起始点一定是dfs树根）for (int i = 0; i < n; ++i) {if (!dfn[i]) dfs(i);}// 拓扑排序int sccadj[scccnt], d[scccnt]; // 新建meta node邻接表，把一个scc缩成一个点memset(sccadj, -1, sizeof sccadj); // 如果某个meta node没有出边，那么邻接表值为-1memset(d, 0, sizeof d);// 现在邻接表中的节点是scc编号for (int i = 0; i < n; ++i) {int x = scc[i], y = scc[adj[i]];if (x != y) {++d[y];sccadj[x] = y;}}int cnt[scccnt]; // 记录每个meta node被指向的节点数，这是拓扑排序真正需要做的事情memset(cnt, 0, sizeof cnt);queue<int> q;for (int i = 0; i < scccnt; ++i) {if (d[i] == 0) q.push(i);}// 这实际上会对多个DAG同时进行拓扑排序，BFS拓扑排序时多个DAG的拓扑序会混杂在一起while (!q.empty()) {int u = q.front();q.pop();if (sccadj[u] != -1) {int v = sccadj[u];cnt[v] += cnt[u] + 1;--d[v];if (d[v] == 0) q.push(v);}}int sccid = -1;for (int i = 0; i < scccnt; ++i) {if (siz[i] > 1) {// L = siz[i], V = cnt[i]// 多关键字排序if (sccid == -1) sccid = i;else if (siz[sccid] - cnt[sccid] < siz[i] - cnt[i]) sccid = i;else if (siz[sccid] - cnt[sccid] == siz[i] - cnt[i] && maxn[sccid] < maxn[i]) sccid = i;}}int cur = minn[sccid];cout << cur;cur = adj[cur];while (cur != minn[sccid]) {cout << ' ' << cur;cur = adj[cur];}
}

时间复杂度：O(n)
空间复杂度：O(n)

解题思路三：java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;/*** @Author jinwang* @Date 2024/5/9 10:48* @Version 1.0 （版本号）*/class Main {private static class node {int maxIdx;int minIdx;int H;public node(int maxIdx, int minIdx, int H) {this.maxIdx = maxIdx;this.minIdx = minIdx;this.H = H;}}public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(br.readLine());int[] arr = new int[n];int[] ru = new int[n];int[] v = new int[n];boolean[] vis = new boolean[n];StringTokenizer st = new StringTokenizer((br.readLine()));for (int i = 0; i < n; i++) {arr[i] = Integer.parseInt(st.nextToken());ru[arr[i]]++;}Queue<Integer> q = new ArrayDeque<>();for (int i = 0; i < n; i++) {if (ru[i] == 0) {q.add(i);}}while (!q.isEmpty()) {int now = q.poll();vis[now] = true;v[arr[now]] += v[now] + 1;ru[arr[now]]--;if (ru[arr[now]] == 0) q.add(arr[now]);}List<node> nodes = new ArrayList<>();for (int i = 0; i < n; i++) {if (!vis[i]) {int now = i, mx = 0, cnt = 0, mn = n, sm = 0;while (!vis[now]) {vis[now] = true;mx = Math.max(mx, now);mn = Math.min(mn, now);cnt += v[now];now = arr[now];sm++;}nodes.add(new node(mx, mn, sm - cnt));}}node ans = nodes.get(0);for (int i = 1; i < nodes.size(); i++) {if (nodes.get(i).H > ans.H || nodes.get(i).H == ans.H && nodes.get(i).maxIdx > ans.maxIdx)ans = nodes.get(i);}System.out.print(ans.minIdx);for (int i = arr[ans.minIdx]; i != ans.minIdx; i = arr[i]) {System.out.print(" " + i);}}
}

时间复杂度：O(n)
空间复杂度：O(n)

---

创作不易，观众老爷们请留步… 动起可爱的小手，点个赞再走呗 (๑◕ܫ￩๑) 欢迎大家关注笔者，你的关注是我持续更博的最大动力

原创文章，转载告知，盗版必究

---

---

---

♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠