Java嵌套for循环优化方案分享

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        if (someCondition(i, j)) {
            // 操作
            break; // 提前退出内层循环
        }
    }
}

// 原始代码
for (int i = 0; i < n; i++) {
    // 操作A
}

for (int i = 0; i < n; i++) {
    // 操作B
}

// 优化后
for (int i = 0; i < n; i++) {
    // 操作A
    // 操作B
}

// 原始代码
for (int i = 0; i < list1.size(); i++) {
    for (int j = 0; j < list2.size(); j++) {
        if (list1.get(i).equals(list2.get(j))) {
            // 操作
        }
    }
}

// 优化后
Map<Type, Boolean> map = new HashMap<>();
for (Type item : list2) {
    map.put(item, true); // 将 list2 的元素放入 Map
}

for (Type item : list1) {
    if (map.containsKey(item)) {
        // 操作
    }
}

// 使用 Java 8 的并行流
list.parallelStream().forEach(item -> {
    // 操作
});

int cachedValue = computeExpensiveValue(); // 预处理计算
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        int result = someFunction(cachedValue, i, j); // 使用缓存值
    }
}

// 原始代码
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        // 操作
    }
}

// 优化后，假设某种操作可以用动态规划优化
int[][] dp = new int[n][m];
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        dp[i][j] = computeValue(i, j, dp); // 使用动态规划缓存结果
    }
}

// 原始代码
for (int i = 0; i < n; i++) {
    List<Integer> tempList = new ArrayList<>();
    // 操作
}

// 优化后，使用对象池
List<List<Integer>> objectPool = new ArrayList<>();
for (int i = 0; i < n; i++) {
    List<Integer> tempList;
    if (i < objectPool.size()) {
        tempList = objectPool.get(i); // 从池中获取对象
    } else {
        tempList = new ArrayList<>();
        objectPool.add(tempList); // 向池中添加新对象
    }
    tempList.clear(); // 清空对象
    // 操作
}

// 原始代码
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        someObject.someMethod(i, j);
    }
}

// 优化后
SomeClass localObject = someObject; // 缓存到本地变量
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        localObject.someMethod(i, j); // 使用本地变量
    }
}

public class LongestIncreasingPath {
    public static void main(String[] args) {
        int[][] matrix = {
            {9, 9, 4},
            {6, 6, 8},
            {2, 1, 1}
        };
        int result = longestIncreasingPath(matrix);
        System.out.println("Longest Increasing Path: " + result); // 应输出4
    }

    public static int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        
        int rows = matrix.length;
        int cols = matrix[0].length;
        int[][] dp = new int[rows][cols]; // 用于保存每个位置的最长递增路径长度
        int maxLength = 0;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                maxLength = Math.max(maxLength, dfs(matrix, dp, i, j));
            }
        }

        return maxLength;
    }

    private static int dfs(int[][] matrix, int[][] dp, int i, int j) {
        if (dp[i][j] != 0) {
            return dp[i][j]; // 如果已经计算过，直接返回结果
        }

        int rows = matrix.length;
        int cols = matrix[0].length;
        int max = 1; // 最短路径长度至少为1（自身）

        // 定义四个方向：上、下、左、右
        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        for (int[] direction : directions) {
            int x = i + direction[0];
            int y = j + direction[1];

            if (x >= 0 && x < rows && y >= 0 && y < cols && matrix[x][y] > matrix[i][j]) {
                max = Math.max(max, 1 + dfs(matrix, dp, x, y));
            }
        }

        dp[i][j] = max; // 缓存结果
        return max;
    }
}