java解一些演算法題

題目描述
某部門計劃透過結隊程式設計來進行專案開發，已知該部門有 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();
    }
}