leetcode day24数学&&day25模拟

最新推荐文章于 2025-12-17 23:41:09 发布

原创最新推荐文章于 2025-12-17 23:41:09 发布 · 359 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

本文介绍了《剑指Offer》书中几道典型的编程题目，包括剪绳子的最大乘积策略、寻找和为s的连续正数序列、圆圈中最后剩下的数字、顺时针打印矩阵以及验证栈的压入、弹出序列。解题思路涉及数值优化、等差数列、循环移位和二维数组操作，体现了对数据结构和算法的应用。

剑指 Offer 14- I. 剪绳子

思路：所有数字均被拆分为2、3，3越多，积越大

public int cuttingRope(int n) {
        if(n==1 || n==2)
            return 1;
        if(n == 3)
            return 2;
            int sum=1;
        while(n>4){
            sum *= 3;
            n -= 3;
        }
        return sum*n;
    }

剑指 Offer 57 - II. 和为s的连续正数序列

思路：刚开始想到了等差数列的求和公式，但具体不知道怎么应用。看了评论区才明白，用left指示首相，right指示末项，根据sum和target大小关系进行移动

public int[][] findContinuousSequence(int target) {
        List<int[]> list = new ArrayList<>();
        int left = 1,right=2;
        while (left < right){
            int sum = (left + right)*(right-left+1)/2;
            if (sum == target){
                int[] temp = new int[right-left+1];
                for (int i=0;i<right-left+1;i++){
                    temp[i] = left+i;
                }
                list.add(temp);
                left++;
            }else if (sum<target){
                right++;
            }else {
                left++;
            }
        }
        return list.toArray(new int[list.size()][]);
    }

剑指 Offer 62. 圆圈中最后剩下的数字

思路：用list存储好进行删除操作。idx记录每次要删除的元素下标，记得%n

public int lastRemaining(int n, int m) {
        List<Integer> list = new ArrayList<>();
        for (int i=0;i<n;i++)
            list.add(i);
        int idx = 0;
        while (n > 1){
            idx = (idx+m-1)%n;//找到要删除的元素
            list.remove(idx);
            n--;
        }
        return list.get(0);
    }

剑指 Offer 29. 顺时针打印矩阵

思路：转一圈要进行四个操作：从左往右--由上往下--从右往左--从下往上。

用top,bottom,left,right指示上下左右边界，注意越界条件

public int[] spiralOrder(int[][] matrix) {
        int row = matrix.length;
        if (row == 0)
            return new int[0];
        int col = matrix[0].length;
        int[] result = new int[row*col];
        int idx = 0;
        int left=0,top=0,right=col-1,bottom = row-1;
        while (true){
            // 从左往右走
            for (int i=left;i<=right;i++){
                result[idx++]=matrix[top][i];
            }
            if (++top > bottom){ //下步该从上往下，找越界条件
                break;
            }
            // 从上往下走
            for (int i=top;i<=bottom;i++){
                result[idx++] = matrix[i][right];
            }
            if (--right<left)//下步该从右往左，想想越界条件
                break;
            // 从右往左
            for (int i=right;i>=left;i--){
                result[idx++] = matrix[bottom][i];
            }
            if (--bottom<top)
                break;
            // 从下往上
            for (int i=bottom;i>=top;i--)
                result[idx++] = matrix[i][left];
            if (++left>right)
                break;
        }
        return result;
    }

剑指 Offer 31. 栈的压入、弹出序列

思路：java一般用双端队列模拟栈的操作。当入栈队列元素和出栈队列元素一样时，执行pop()操作，不一样时执行push()操作。若能遍历至poped[]数组最后，表示true；否则false

public boolean validateStackSequences(int[] pushed, int[] popped) {
        Deque<Integer> stack = new ArrayDeque();
        int j = 0;
        for (int elem : pushed) {
            stack.push(elem);
            while (j < popped.length && !stack.isEmpty() && stack.peek() == popped[j]) {
                stack.pop();
                j++;
            }
        }
        return j == popped.length;
    }