数组算法题

原创 已于 2025-05-09 08:34:13 修改 · 864 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java

于 2025-05-09 08:30:07 首次发布

1：

 思路：

  1. 首先判断数组长度，如果长度小于 3，直接返回 0，因为等差数列至少需要三个元素。
  2. 初始化一个 dp 数组，dp[i]表示以nums[i]结尾的等差子数组的个数。
  3. 遍历数组，从索引 2 开始，检查当前元素和前两个元素是否构成等差数列。如果nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]，说明以nums[i]结尾的等差子数组个数是dp[i - 1] + 1。
  4. 最后遍历 dp 数组，累加所有元素的值，即为所有等差子数组的个数。

代码：

public class Solution {
    public int numberOfArithmeticSlices(int[] nums) {
        int n = nums.length;
        if (n < 3) {
            return 0;
        }
        int[] dp = new int[n];
        for (int i = 2; i < n; i++) {
            if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
                dp[i] = dp[i - 1] + 1;
            }
        }
        int sum = 0;
        for (int count : dp) {
            sum += count;
        }
        return sum;
    }
}

结果: 

 为什么是dp[i - 1] + 1。

在动态规划的解法中，dp[i] = dp[i - 1] + 1 的核心逻辑在于：当以位置 i 结尾的子数组满足等差数列条件时，它会继承之前所有的等差数列，并新增一个长度为 3 的等差数列。以下是详细解释：

关键理解点

  1. 等差数列的连续性
    题目要求子数组必须是连续的。因此，当位置 i 能与前两个位置 i-1 和 i-2 构成等差数列时，所有以 i-1 结尾的等差数列都可以延伸到 i。

  2. 继承性
    如果 nums[i-2], nums[i-1], nums[i] 构成等差数列，那么：

    • 所有以 i-1 结尾的等差数列（共有 dp[i-1] 个），都可以加上 nums[i] 形成更长的等差数列。
    • 新增一个长度为 3 的等差数列：即 nums[i-2], nums[i-1], nums[i] 本身。

  3. 数学归纳
    例如：

    • 当 dp[i-1] = 2 时（表示以 i-1 结尾的等差数列有 2 个），若 i 加入后仍满足等差数列条件，则以 i 结尾的等差数列数量为：
      • 原有的 2 个延伸到 i，新增 1 个长度为 3 的数列，因此 dp[i] = 2 + 1 = 3。

示例说明

假设数组为 nums = [1, 2, 3, 4, 5]：

  • i=2（元素 3）：

    • nums[0]=1, nums[1]=2, nums[2]=3 构成等差数列，长度为 3，因此 dp[2] = 1。

  • i=3（元素 4）：

    • nums[1]=2, nums[2]=3, nums[3]=4 构成等差数列，继承 dp[2]=1，新增 1 个，因此 dp[3] = 1 + 1 = 2。
    • 此时以 i=3 结尾的等差数列为 [1,2,3,4] 和 [2,3,4]。

  • i=4（元素 5）：

    • nums[2]=3, nums[3]=4, nums[4]=5 构成等差数列，继承 dp[3]=2，新增 1 个，因此 dp[4] = 2 + 1 = 3。
    • 此时以 i=4 结尾的等差数列为 [1,2,3,4,5], [2,3,4,5], [3,4,5]。

总结

dp[i-1] + 1 的本质是：

  • dp[i-1]：继承所有以 i-1 结尾的等差数列。
  • +1：新增一个由 i-2, i-1, i 构成的长度为 3 的等差数列。

这种递推关系确保了动态规划能够高效统计所有可能的等差数列子数组。

2:

 思路：

  1. 初始化：首先判断输入矩阵是否有效，然后获取矩阵的行数m和列数n，并初始化两个布尔型二维数组pacific和atlantic，用于记录可以流向太平洋和大西洋的单元格。
  2. DFS 函数：递归函数dfs用于从当前单元格出发，探索所有可以到达的更高或等高的单元格，并将这些单元格在对应的布尔数组中标记为true。
  3. 太平洋边界处理：从左边界和上边界的每个单元格出发，调用 DFS 函数，将可以到达的单元格在pacific数组中标记为true。
  4. 大西洋边界处理：从右边界和下边界的每个单元格出发，调用 DFS 函数，将可以到达的单元格在atlantic数组中标记为true。
  5. 求交集：遍历所有单元格，将同时在pacific和atlantic数组中被标记为true的单元格添加到结果列表中。

代码：

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

class Solution {
    private int[][] heights;
    private int m, n;
    
    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        List<List<Integer>> result = new ArrayList<>();
        if (heights == null || heights.length == 0 || heights[0].length == 0) {
            return result;
        }
        
        this.heights = heights;
        m = heights.length;
        n = heights[0].length;
        
        boolean[][] pacific = new boolean[m][n];
        boolean[][] atlantic = new boolean[m][n];
        
        // 从太平洋边界开始DFS
        for (int r = 0; r < m; r++) {
            dfs(r, 0, pacific, Integer.MIN_VALUE);
        }
        for (int c = 0; c < n; c++) {
            dfs(0, c, pacific, Integer.MIN_VALUE);
        }
        
        // 从大西洋边界开始DFS
        for (int r = 0; r < m; r++) {
            dfs(r, n - 1, atlantic, Integer.MIN_VALUE);
        }
        for (int c = 0; c < n; c++) {
            dfs(m - 1, c, atlantic, Integer.MIN_VALUE);
        }
        
        // 找出同时满足两个条件的坐标
        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                if (pacific[r][c] && atlantic[r][c]) {
                    result.add(List.of(r, c));
                }
            }
        }
        
        return result;
    }
    
    private void dfs(int r, int c, boolean[][] visited, int prevHeight) {
        if (r < 0 || c < 0 || r >= m || c >= n || visited[r][c] || heights[r][c] < prevHeight) {
            return;
        }
        
        visited[r][c] = true;
        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        for (int[] dir : directions) {
            dfs(r + dir[0], c + dir[1], visited, heights[r][c]);
        }
    }
}

 结果:

 核心思路

水从高处流向低处，但我们可以反向思考：从海洋边界（太平洋和大西洋）出发，找到所有能从海洋逆流而上到达的单元格。如果某个单元格既可以从太平洋到达，也可以从大西洋到达，那么它就是符合条件的解。

代码结构与关键步骤

1. 初始化与边界检查

if (heights == null || heights.length == 0 || heights[0].length == 0) {
    return result;
}
  • 处理空输入的情况，直接返回空结果。

2. 全局变量与矩阵尺寸

private int[][] heights;
private int m, n;
  • heights：存储输入矩阵。
  • m 和 n：矩阵的行数和列数。

3. 标记数组初始化

boolean[][] pacific = new boolean[m][n];
boolean[][] atlantic = new boolean[m][n];
  • pacific[r][c]：表示坐标 (r, c) 是否能流向太平洋。
  • atlantic[r][c]：表示坐标 (r, c) 是否能流向大西洋。

4. 从边界开始 DFS 探索

太平洋边界（左 + 上）
// 左边界（所有行的第0列）
for (int r = 0; r < m; r++) {
    dfs(r, 0, pacific, Integer.MIN_VALUE);
}
// 上边界（第0行的所有列）
for (int c = 0; c < n; c++) {
    dfs(0, c, pacific, Integer.MIN_VALUE);
}
  • 从左边界（c=0）和上边界（r=0）的所有单元格出发，标记能逆流到达的单元格。
大西洋边界（右 + 下） 
// 右边界（所有行的最后一列）
for (int r = 0; r < m; r++) {
    dfs(r, n - 1, atlantic, Integer.MIN_VALUE);
}
// 下边界（最后一行的所有列）
for (int c = 0; c < n; c++) {
    dfs(m - 1, c, atlantic, Integer.MIN_VALUE);
}

 从右边界（c=n-1）和下边界（r=m-1）的所有单元格出发，标记能逆流到达的单元格

5. DFS 深度优先搜索函数

private void dfs(int r, int c, boolean[][] visited, int prevHeight) {
    if (r < 0 || c < 0 || r >= m || c >= n || visited[r][c] || heights[r][c] < prevHeight) {
        return;
    }
    
    visited[r][c] = true;
    int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    
    for (int[] dir : directions) {
        dfs(r + dir[0], c + dir[1], visited, heights[r][c]);
    }
}
  • 终止条件：
    • 越界（r < 0 或 c < 0 或 r >= m 或 c >= n）。
    • 已访问（visited[r][c] 为 true）。
    • 当前高度小于上一个单元格的高度（heights[r][c] < prevHeight），说明无法从当前单元格流向之前的单元格。
  • 标记当前单元格：visited[r][c] = true。
  • 递归探索四个方向：上、下、左、右。

6. 结果收集

for (int r = 0; r < m; r++) {
    for (int c = 0; c < n; c++) {
        if (pacific[r][c] && atlantic[r][c]) {
            result.add(List.of(r, c));
        }
    }
}

复杂度分析

  • 时间复杂度：O(m*n)，每个单元格最多被访问两次（一次从太平洋边界，一次从大西洋边界）。
  • 空间复杂度：O(m*n)，主要用于存储两个标记数组。

Java—数组中涉及的常见算法
小贺想改变
09-04 930
数组元素的赋值(杨辉三角、回形数等)，求数值型数组中元素的最大值、最小值、平均数、总和等，数组的复制、反转、查找(线性查找、二分法查找)，数组元素的排序算法
Java中二维数组练习题
小贺想改变
09-02 2041
Java中二维数组练习题
数组相关算法题汇总
qq_43103261的博客
01-05 1686
在属于数组考点系列的题目中，划分为四个常考问题：子数组问题、矩阵问题、O(n)类型问题和思维转换类型问题。 子数组问题：就是给定一个数组，围绕该数组的子数组列出诸多难题，等待我们来解答。 矩阵问题：给定一个矩阵（或者称为二维数组），围绕该矩阵列出不同方式遍历矩阵中元素等难题，等待我们来解答。 O(n)类型问题：O(n)是指时间复杂度为O(n)，给定的题目题意一般很容易理解，其一般解法（俗称暴力解法，时间复杂度一般为O(n^2)，甚至更高）也很简单，但是题目要求你的解法时间复杂度为O(n)。看到这些题目
数组相关算法题（一）
ym563099457的博客
05-18 3563
数组相关算法题： 1 二分查找 给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 ...
算法之数组常见题目
ChenYiRan123456的博客
01-01 604
数组是存储在连续内存空间上的相同类型数据的集合。在数组中可以方便地通过下标索引的方式获取对应的数据。leedcode26：删除有序数组中的重复项leedcode724：寻找数组的中心下标leedcode59. 螺旋矩阵 II
【算法刷题】数组题型及方法归纳
STAR GAME
03-17 814
1. 二分查找：双指针法[左右] 二分查找（C++、Python3） 39、【查找】二分查找：数的范围和查找某个数（C/C++版） （1）方法：双指针法，数组两端设置左指针和右指针。 （2）注意：边界问题取值。 [,]：左闭右闭，左右两端指针均可以取到对应位置，则为 <= left = mid + 1 、rigth = mid - 1 、mid = (right + left) / 2 [,)：左闭右开，左可以取到右边取不到，则为< left = mid + 1、right = mid、mid
数组--02---常见算法题、 Arrays工具类
时光里的博客
08-02 243
数组 中涉及的常见算法 题目 1 : 杨辉三 角 方法1 public class YangHuiTest { public static void main(String[] args) { //1.声明并初始化二维数组 int[][] yangHui = new int[10][]; //2.给数组的元素赋值 for (int i = 0; i < yangHui.length; i++) { y
直击高频编程考点：数组知识及经典算法题总结
热门推荐
张彦峰的博客
10-27 5万+
数组基础、应用以及编程练习（找到数组 A 元素组成的小于 n的最大整数+两数之和 +三数之和 +最接近的三数之和+移动零 +旋转数组+搜索旋转排序数组 +寻找旋转排序数组中的最小值 +加一 +存在重复元素 +寻找数组的中心索引+翻转对 +只出现一次的数字+合并两个有序数组+合并区间+最大子序列+最长连续递增序列+最长公共前缀+移除元素+除自身以外数组乘积+颜色分类）
力扣官方测试：解决长度20000的和为K的子数组算法题
资源摘要信息: "力扣算法题：和为K的子数组" 知识点: 1. 力扣（LeetCode）介绍： 力扣是一个面向全球软件工程师和程序员的在线编程平台，提供各种编程语言的编程题目，以帮助开发者通过在线编程练习提升算法和...
旋转图像（二维数组的旋转）——LeetCode数组算法题
likunkun__的博客
06-20 2993
旋转图像给定一个 n × n 的二维矩阵表示一个图像。将图像顺时针旋转 90 度。说明：你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。示例 1:给定 matrix = [ [1,2,3], [4,5,6], [7,8,9] ], 原地旋转输入矩阵，使其变为: [ [7,4,1], [8,5,2], [9,6,3] ] 示例 ...
浅谈js中字符和数组一些基本算法题
10-21
下面小编就为大家带来一篇浅谈js中字符和数组一些基本算法题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
算法分类数组经典题目
我是Java程序员廖志伟，感谢朋友们的支持！
09-07 284
数组是大多数程序语言中最基本的数据结构之一，也是用得最多的数据结构之一，因此对数组的操作和应用非常重要。我们可以建立一个哈希表，用来存储每个数及其对应的下标，然后遍历数组，对于每个数，我们在哈希表中查询是否存在有相加等于target的数，如果存在，就可以返回答案。假设有两个指针i和j，其中i指向当前已经处理好的序列的尾部，j则是当前遍历到的下标。给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。给定一个数组，将数组中的元素向右移动k个位置，其中k是非负数。
数组常见算法
weixin_64975807的博客
03-05 2235
数组排序、数组有序和无序查找和数组旋转、乱序算法
数组算法练习题01
a773794783的博客
09-21 124
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。给你一个 升序排列 的数组 nums ，请你原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
【数组、字符串】算法例题
QiAn的博客
03-19 1189
给你一个字符串s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。单词是指仅由字母组成、不包含任何空格字符的最大子字符串。示例 1：5最后一个单词是“World”，长度为5。示例 2：4最后一个单词是“moon”，长度为4。示例 3：6最后一个单词是长度为6的“joyboy”。s仅有英文字母和空格' '组成s中至少存在一个单词方法1：（0ms）right--;
数组类算法题
vivian233的博客
04-06 492
1. 求两数和 给出一个整数数组，请在数组中找出两个加起来等于目标值的数，你给出的函数twoSum 需要返回这两个数字的下标（index1，index2），需要满足index1 小于index2.。注意：下标是从1开始的 public int[] twoSum (int[] numbers, int target) { // write code here Map<Integer, Integer> map = new HashMap<>();.
数组相关算法题
qq_52597311的博客
09-07 389
数组相关的一些题目分享
关于数组的常见算法题（随时更新）
求职之路
05-20 1917
一、求出数组中的第二大的元素 方法一： 先将数据排序好（快速排序），然后根据下标寻找第二大的元素 注意事项： （1）如果元素都是同一个数，那么没有第二大 （2）最大的可能不止一个，所以不能直接输出arr[len-2]，也要进行判断 public class FindSecondMax { public static void quickSelect(int[] arr,int start,in...
算法学习随笔 2_数组有关算法题
P_in_k的博客
03-03 475
算法学习随笔系列文章旨在记录和梳理本人学习算法过程当中遇到的问题和知识点，同时希望可以和大家交流，共同学习。作为一名学习者，难免有错误的地方，希望大家指正。
java数组算法题入门
最新发布
04-03
### Java数组算法题入门教程 Java中的数组是一种基本的数据结构，用于存储相同类型的多个数据项。以下是关于Java数组的基础知识以及一些简单的算法题解析。 #### 什么是数组？ 数组是一个可以存储固定数量元素的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值