題目描述
某部門計劃透過結隊程式設計來進行專案開發，已知該部門有 N 名員工，每個員工有獨一無二的職級，每三個員工形成一個小組進行結隊程式設計。
結隊分組規則如下： 從部門中選出序號分別為i、j、k 的 3 名員工，他們的職級分別為 level[i], level[j], level[k]
結隊小組需滿足 level[i] < level[j] < level[k] 或者 level[i] > level[j] > level[k] ，其中 0 ⩽ i < j < k < n 請你按上述條件計算可能組合的小組數量。
同一員工可以參加多個小組。
輸入
第一行輸入：員工總數 n
第二行輸入：按序號依次排列的員工的職級 level，中間用空格隔開
限制：
1 ⩽ n ⩽ 6000
1 ⩽ level[i] ⩽ 10^5
輸出
可能組合的小組數量
樣例輸入 複製
4
1 2 3 4
樣例輸出 複製
4
提示
可能結隊成的組合 (1,2,3)、(1,2,4)、(1,3,4)、(2,3,4)。
import java.util.Scanner;
public class TripletCounter {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 讀取員工總數
int n = scanner.nextInt();
// 讀取員工的職級
int[] levels = new int[n];
for (int i = 0; i < n; i++) {
levels[i] = scanner.nextInt();
}
// 計算並輸出可能組合的小組數量
int result = countTriplets(levels);
System.out.println(result);
}
private static int countTriplets(int[] levels) {
int n = levels.length;
int count = 0;
for (int i = 0; i < n - 2; i++) {
for (int j = i + 1; j < n - 1; j++) {
for (int k = j + 1; k < n; k++) {
if ((levels[i] < levels[j] < levels[k]) || (levels[i] > levels[j] > levels[k])) {
count++;
}
}
}
}
return count;
}
}
題目描述
在一個機房中，伺服器的位置標識在 n*m 的整數矩陣網格中，1 表示單元格上有伺服器，0 表示沒有。如果兩臺伺服器位於同一行或者同一列中緊鄰的位置，則認為它們之間可以組成一個區域網。
請你統計機房中最大的區域網包含的伺服器個數。
輸入描述
第一行輸入兩個正整數，n和m，0<n,m<=100
之後為n*m的二維陣列，代表伺服器資訊
輸出描述
最大區域網包含的伺服器個數。
用例
輸入 2 2
1 0
1 1
輸出 3
說明 [0][0]、[1][0]、[1][1]三臺伺服器相互連線，可以組成區域網
import java.util.Scanner;
public class LargestNetwork {
private static int n, m;
private static int[][] grid;
private static boolean[][] visited;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 讀取 n 和 m
n = scanner.nextInt();
m = scanner.nextInt();
// 初始化網格和訪問標記陣列
grid = new int[n][m];
visited = new boolean[n][m];
// 讀取網格資料
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
grid[i][j] = scanner.nextInt();
}
}
int maxNetworkSize = 0;
// 遍歷網格，查詢最大的區域網
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == 1 && !visited[i][j]) {
int networkSize = dfs(i, j);
maxNetworkSize = Math.max(maxNetworkSize, networkSize);
}
}
}
// 輸出結果
System.out.println(maxNetworkSize);
}
// 深度優先搜尋方法，返回區域網大小
private static int dfs(int x, int y) {
// 定義移動方向：上、下、左、右
int[] dx = {-1, 1, 0, 0};
int[] dy = {0, 0, -1, 1};
visited[x][y] = true;
int size = 1;
// 遍歷四個方向
for (int i = 0; i < 4; i++) {
int newX = x + dx[i];
int newY = y + dy[i];
if (isValid(newX, newY) && grid[newX][newY] == 1 && !visited[newX][newY]) {
size += dfs(newX, newY);
}
}
return size;
}
// 檢查座標是否有效
private static boolean isValid(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m;
}
}
題目描述
有一棵二叉樹，每個節點由一個大寫字母標識(最多26個節點）。
現有兩組字母，分別表示後序遍歷（左孩子->右孩子->父節點）和中序遍歷（左孩子->父節點->右孩子）的結果，請輸出層次遍歷的結果。
輸入描述
輸入為兩個字串，分別是二叉樹的後續遍歷和中序遍歷結果。
輸出描述
輸出二叉樹的層次遍歷結果。
示例1
輸入：
CBEFDA CBAEDF
輸出：
ABDCEF
說明：
二叉樹為：
A
/
B D
/ /
C E F
import java.util.*;
class TreeNode {
char val;
TreeNode left;
TreeNode right;
TreeNode(char x) {
val = x;
}
}
public class BinaryTreeTraversal {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 讀取後序遍歷和中序遍歷字串
String postorder = scanner.next();
String inorder = scanner.next();
// 構建二叉樹
TreeNode root = buildTree(postorder, inorder);
// 層次遍歷二叉樹並輸出結果
String levelOrder = levelOrderTraversal(root);
System.out.println(levelOrder);
}
// 從後序遍歷和中序遍歷構建二叉樹
private static TreeNode buildTree(String postorder, String inorder) {
if (postorder == null || inorder == null || postorder.length() != inorder.length()) {
return null;
}
Map<Character, Integer> inorderMap = new HashMap<>();
for (int i = 0; i < inorder.length(); i++) {
inorderMap.put(inorder.charAt(i), i);
}
return buildTreeHelper(postorder, 0, postorder.length() - 1, inorder, 0, inorder.length() - 1, inorderMap);
}
private static TreeNode buildTreeHelper(String postorder, int postStart, int postEnd,
String inorder, int inStart, int inEnd,
Map<Character, Integer> inorderMap) {
if (postStart > postEnd || inStart > inEnd) {
return null;
}
char rootVal = postorder.charAt(postEnd);
TreeNode root = new TreeNode(rootVal);
int inorderRootIndex = inorderMap.get(rootVal);
int leftTreeSize = inorderRootIndex - inStart;
root.left = buildTreeHelper(postorder, postStart, postStart + leftTreeSize - 1,
inorder, inStart, inorderRootIndex - 1, inorderMap);
root.right = buildTreeHelper(postorder, postStart + leftTreeSize, postEnd - 1,
inorder, inorderRootIndex + 1, inEnd, inorderMap);
return root;
}
// 層次遍歷二叉樹
private static String levelOrderTraversal(TreeNode root) {
if (root == null) {
return "";
}
StringBuilder result = new StringBuilder();
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
result.append(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
return result.toString();
}
}