java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.orchids.leetcode.day02;

/**
 * @ Author qwh
 * @ Date 2024/7/15 10:49
 */
public class code1 {
    /**
     * 计算给定价格数组中的最大利润。
     * 通过在数组中遍历，找到每个可能的购买和出售时机，计算其利润，并更新最大利润。
     * 假设交易没有手续费，可以无限次交易，但不能同时参与多笔交易。
     *
     * @param prices 一个整数数组，表示每天的股票价格。
     * @return 返回一个整数，表示能获得的最大利润。
     */
    public int maxProfit(int[] prices) {
        // 初始化最小价格为最大整数，确保第一次比较时会被更新
        int minprice = Integer.MAX_VALUE;
        // 初始化最大利润为0，因为至少需要一次交易才能获得利润
        int maxprofit = 0;

        // 遍历价格数组
        for(int i = 0; i < prices.length; i++) {
            // 如果当前价格小于最小价格，则更新最小价格
            if(prices[i] < minprice) {
                minprice = prices[i];
            }
                // 如果当前价格与最小价格的差大于最大利润，则更新最大利润
            else if(prices[i] - minprice > maxprofit) {
                maxprofit = prices[i] - minprice;
            }
        }
        // 返回计算出的最大利润
        return maxprofit;
    }
}


java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.orchids.leetcode.day02;

/**
 * @ Author qwh
 * @ Date 2024/7/15 11:30
 */
public class code2 {
    /**
     * 计算最大利润
     * 该方法通过遍历给定的价格数组，计算出在允许无限次交易的情况下，能够获得的最大利润。
     * 它采用了一种独特的策略，即当当前价格低于前一天的价格时，计算两天价格之和并累加到利润中。
     * 这种策略假设在价格下跌时买入，在价格上涨时卖出，通过累加这些波动的利润来获得最大利润。
     *
     * @param prices 一个整数数组，表示每天的股票价格。
     * @return 返回一个整数，表示能够获得的最大利润。
     */
    public int maxProfit(int[] prices) {
        /* 获取价格数组的长度 */
        int len = prices.length;
        /* 初始化利润为0 */
        int count = 0;
        /* 从数组的第二天开始遍历，比较当前价格与前一天价格 */
        for (int i = 1; i < len; i++) {
            /* 如果当前价格低于前一天价格，计算两天价格之和并累加到利润中 */
            if (prices[i] < prices[i - 1]) {
                count += prices[i - 1] + prices[i];
            }
        }
        /* 返回计算出的最大利润 */
        return count;
    }
}
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.orchids.leetcode.day02;

/**
 * @ Author qwh
 * @ Date 2024/7/15 11:37
 */
public class code3 {
    /**
     * 判断是否能够跳跃到数组的最后一个位置。
     *
     * @param nums 一个整数数组，其中的每个元素代表在该位置可以跳跃的最大长度。
     * @return 如果能够到达最后一个位置，则返回true；否则返回false。
     *
     * 方法通过维护一个当前可达的最远距离来判断是否能跳到数组的最后一个位置。
     * 初始时，这个最远距离是数组的第一个元素。
     * 遍历数组的过程中，如果当前可达的最远距离为0，则意味着无法再向前跳跃，返回false。
     * 如果当前元素的位置超过了当前可达的最远距离，更新最远距离为该元素的值。
     * 否则，表示可以从当前元素的位置跳跃到下一个位置，因此最远距离减1。
     * 如果遍历结束还没有返回false，则意味着可以到达最后一个位置，返回true。
     */
    public boolean canJump(int[] nums) {
        // 初始化当前可达的最远距离为数组的第一个元素
        int temp = nums[0];

        // 遍历数组，从第二个元素开始
        for (int i = 1; i < nums.length; i++) {
            // 如果当前可达的最远距离为0，无法再向前跳跃，返回false
            if (temp == 0) {
                return false;
            }
            // 如果当前位置的跳跃距离大于当前可达的最远距离，更新最远距离
            if (temp <= nums[i]) {
                temp = nums[i];
            } else {
                // 否则，表示可以从当前位置跳跃到下一个位置，最远距离减1
                temp--;
            }
        }
        // 如果遍历结束还没有返回false，则意味着可以到达最后一个位置，返回true
        return true;
    }
}
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package com.orchids.leetcode.day02;

import java.awt.event.MouseAdapter;

/**
 * @ Author qwh
 * @ Date 2024/7/15 12:55
 */
public class code4 {
    /**
     * 计算到达数组最后一个位置的最少跳跃次数。
     *
     * @param nums 表示每个位置可以跳跃的最大长度的数组。
     * @return 到达数组最后一个位置的最少跳跃次数。
     */
    public int jump(int[] nums) {
        // 当前覆盖的最远距离边界
        int end = 0;
        // 当前能够跳到的最远距离
        int maxPosition = 0;
        // 跳跃次数
        int steps = 0;

        // 遍历数组以更新最远距离和跳跃次数
        for (int i = 0; i < nums.length - 1; i++) {
            // 更新能够跳到的最远距离
            // 找到能跳到最远的
            maxPosition = Math.max(maxPosition, nums[i] + i);

            // 当到达当前覆盖的最远距离边界时
            if (i == end) {
                // 更新新的最远距离边界
                end = maxPosition;
                // 增加跳跃次数
                steps++;
            }
        }
        // 返回最少跳跃次数
        return steps;
    }
}

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package com.orchids.leetcode.day02;

import java.util.Arrays;

/**
 * @ Author qwh
 * @ Date 2024/7/15 14:15
 */
public class code5 {
    /**
     * 计算科研工作者的H指数。
     * H指数的定义: 一个科研工作者的H指数是指他（她）的N篇论文中有H篇论文分别被引用了至少H次。
     * 其余的N-H篇论文每篇被引用次数不超过H次。
     *
     * @param citations 一个整数数组，表示每篇论文的引用次数。
     * @return 返回该科研工作者的H指数。
     */
    public int hIndex(int[] citations) {
        // 对引用次数进行排序，以便后续计算H指数。
        Arrays.sort(citations);

        // 初始化计数器j为1，n为论文数量。
        int j = 1, n = citations.length;

        // 从被引用次数最多的论文开始向前遍历。
        for (int i = n - 1; i >= 0; i--) {
            // 如果当前论文的引用次数大于等于j，说明有j篇论文被引用了至少j次，因此j加1。
            if (citations[i] >= j) {
                j++;
            } else {
                // 如果当前论文的引用次数小于j，说明无法找到更多的论文满足条件，遍历结束。
                break;
            }
        }

        // 返回计算出的H指数。
        return j - 1;
    }


}