g0601_0700.s0673_number_of_longest_increasing_subsequence.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0601_0700.s0673_number_of_longest_increasing_subsequence;

// #Medium #Array #Dynamic_Programming #Segment_Tree #Binary_Indexed_Tree
// #Algorithm_II_Day_16_Dynamic_Programming #2022_03_22_Time_25_ms_(68.75%)_Space_44.5_MB_(35.85%)

/**
 * 673 - Number of Longest Increasing Subsequence\.
 *
 * Medium
 *
 * Given an integer array `nums`, return _the number of longest increasing subsequences._
 *
 * **Notice** that the sequence has to be **strictly** increasing.
 *
 * **Example 1:**
 *
 * **Input:** nums = [1,3,5,4,7]
 *
 * **Output:** 2
 *
 * **Explanation:** The two longest increasing subsequences are [1, 3, 4, 7] and [1, 3, 5, 7].
 *
 * **Example 2:**
 *
 * **Input:** nums = [2,2,2,2,2]
 *
 * **Output:** 5
 *
 * **Explanation:** The length of longest continuous increasing subsequence is 1, and there are 5 subsequences' length is 1, so output 5.
 *
 * **Constraints:**
 *
 * *   `1 <= nums.length <= 2000`
 * *   -10⁶ <= nums[i] <= 10⁶
**/
public class Solution {
    public int findNumberOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        int[] count = new int[nums.length];
        dp[0] = 1;
        count[0] = 1;
        int result = 0;
        int max = Integer.MIN_VALUE;
        for (int i = 1; i < nums.length; i++) {
            dp[i] = 1;
            count[i] = 1;
            for (int j = i - 1; j >= 0; j--) {
                if (nums[j] < nums[i]) {
                    if (dp[i] < dp[j] + 1) {
                        dp[i] = dp[j] + 1;
                        count[i] = count[j];
                    } else if (dp[i] == dp[j] + 1) {
                        count[i] += count[j];
                    }
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (max < dp[i]) {
                result = count[i];
                max = dp[i];
            } else if (max == dp[i]) {
                result += count[i];
            }
        }
        return result;
    }
}