经典习题++

Arrays.stream

//给你一个 m x n 的整数网格 accounts ，
//其中 accounts[i][j] 是第 i位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
//客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。


import java.util.Arrays;

public class Demo20 {
    public static void main(String[] args) {
        int[][] accounts = {{1, 2, 3}, {3, 2, 1}};
        System.out.println(maximumWealth(accounts));
    }

    public static int maximumWealth(int[][] accounts) {
        int maxWealth = Integer.MIN_VALUE;
        for (int[] account : accounts) {
            maxWealth = Math.max(maxWealth, Arrays.stream(account).sum()); //
        }
        return maxWealth;
    }
}
/*
    public static int maximumWealth(int[][] accounts) {
        int maxTotalAssets = 0;
        for (int i = 0; i < accounts.length; i++) {
            int totalAssets = 0;
            for (int j = 0; j < accounts[i].length; j++) {
                totalAssets += accounts[i][j];
            }
            if (totalAssets > maxTotalAssets) {
                maxTotalAssets = totalAssets;
            }
        }
        return maxTotalAssets;
    }
}

 */

数组右边第一个更大元素（单调栈+哈希表）

// nums1中数字x的下一个更大元素是指x在nums2中对应位置右侧的第一个比x大的元素。
// 给你两个没有重复元素的数组nums1和nums2,下标从0开始计数，其中nums1是nums2的子集。
// 对于每个0<=i<nums1.length ，找出满足nums1[i]==nums2[j] 的下标j，并且在nums2确定nums2[j]的下一个更大元素 。
// 如果不存在下一个更大元素，那么本次查询的答案是 -1 。
// 返回一个长度为nums1.length 的数组 ans 作为答案，满足ans[i]是如上所述的下一个更大元素 。

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;

public class Demo16 {
    public static void main(String[] args) {
        int[] nums1 = {4, 1, 2};
        int[] nums2 = {1, 3, 4, 2};
        for (int i : nextGreaterElement(nums1, nums2)) {
            System.out.println(i);
        }

    }

    // 单调栈 + 哈希表
    public static int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        Deque<Integer> stack = new ArrayDeque<Integer>();
        for (int i = nums2.length - 1; i >= 0; --i) {
            int num = nums2[i];
            while (!stack.isEmpty() && num >= stack.peek()) {
                stack.pop();
            }
            map.put(num, stack.isEmpty() ? -1 : stack.peek());
            stack.push(num);
        }
        int[] res = new int[nums1.length];
        for (int i = 0; i < nums1.length; ++i) {
            res[i] = map.get(nums1[i]);
        }
        return res;
    }
}

各个坐标是否在同一直线

// 给定一个数组coordinates，其中coordinates[i] = [x, y]，[x, y]表示横坐标为 x、纵坐标为 y的点。
// 请你来判断，这些点是否在该坐标系中属于同一条直线上。

public class Demo17 {
    public static void main(String[] args) {
        int[][] coordinates = {{1, 1}, {2, 2}, {3, 4}, {4, 5}, {5, 6}, {7, 7}};
        System.out.println(checkStraightLine(coordinates));
    }

    public static boolean checkStraightLine(int[][] coordinates) {
        int deltaX = coordinates[0][0], deltaY = coordinates[0][1];
        int n = coordinates.length;
        for (int i = 0; i < n; i++) {
            coordinates[i][0] -= deltaX;
            coordinates[i][1] -= deltaY;
        }
        int A = coordinates[1][1], B = -coordinates[1][0];
        for (int i = 2; i < n; i++) {
            int x = coordinates[i][0], y = coordinates[i][1];
            if (A * x + B * y != 0) {
                return false;
            }
        }
        return true;
    }
}

字符串一次交换是否相等

// 给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下：选出某个字符串中的两个下标（不必不同），
// 并交换这两个下标所对应的字符。
// 如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等，返回 true ；否则，返回 false 。

import java.util.ArrayList;
import java.util.List;

public class Demo14 {
    public static void main(String[] args) {
        String s1 = "caa";
        String s2 = "aaz";
        System.out.println(areAlmostEqual(s1, s2));
    }

    public static boolean areAlmostEqual(String s1, String s2) {
        int n = s1.length();
        List<Integer> diff = new ArrayList<Integer>();
        for (int i = 0; i < n; ++i) {
            if (s1.charAt(i) != s2.charAt(i)) {
                if (diff.size() >= 2) {
                    return false;
                }
                diff.add(i);
            }
        }
        if (diff.isEmpty()) {
            return true;
        }
        if (diff.size() == 1) {
            return false;
        }
        return s1.charAt(diff.get(0)) == s2.charAt(diff.get(1))
                && s1.charAt(diff.get(1)) == s2.charAt(diff.get(0));
    }
}

重塑矩阵

import java.util.Arrays;

//在 MATLAB 中，有一个非常有用的函数 reshape
//它可以将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。
//给你一个由二维数组 mat 表示的 m x n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。
//重构后的矩阵需要将原始矩阵的所有元素以相同的 行遍历顺序 填充。
//如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。
public class Demo22 {
    public static void main(String[] args) {
        int[][] mat = {{1, 2}, {3, 4}};
        int r = 1;
        int c = 4;
        // 二维数组字符串形式输出
        System.out.println(Arrays.deepToString(matrixReshape(mat,r,c)));
    }


    public static int[][] matrixReshape(int[][] nums, int r, int c) {
        int m = nums.length;
        int n = nums[0].length;
        // 判断重塑后的数组元素个数是否不变
        if (m * n != r * c) {
            return nums;
        }

        int[][] ans = new int[r][c];
        // 一共有m*n个元素
        for (int x = 0; x < m * n; ++x) {
            // 因为需要满足行遍历顺序，所以第 x个元素在原数组中的位置为（x/n，x%n），在重塑数组中的位置（x/c，x%c）
            ans[x / c][x % c] = nums[x / n][x % n];
        }
        return ans;
    }
}