class Solution {

    public int lengthOfLIS(int[] nums) {

        int[] dp = new int[nums.length];

        for(int i = 0;i < nums.length;i++) {
            dp[i] = 1;
        }

        int res = 1;
        for(int i = 1;i < nums.length;i++) {
            for(int j = 0;j < i;j++) {
                if(nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i],dp[j] + 1);
                }
            }
            res = Math.max(res,dp[i]);
        }

        return res;

    }
}

😉正经点，解题思路

本题要的是，最长递增子序列的个数，那么我们得知道最长是多少，才能再去求最长得序列个数是多少！

利用动态规划，设置int[] dp = new int[nums.length];数组记录长度，设置int[] counts = new int[nums.length];记录个数

那么状态如何转移呢❔

如果有熟悉 300.最长子序列的小伙伴可能知道，我也不废话

因为要递增，所以⏬
当j < i && nums[j] < nums[i]的时候，就需要去判断当前 dp[j] + 1 > dp[i]，
如果为true，说明：dp[j]是不能接在dp[i]前面，递增序列有更大的长度，那么需要更新长度，既然有更大的长度，那么 counts[i] = counts[j]，因为count[i]所以记录的个数已经无效了

但如果dp[j] + 1 == dp[i]，说明dp[j]是可以接在dp[i]前面的，所以要 counts[i] += counts[j];

🌈代码实现

class Solution {
    public int findNumberOfLIS(int[] nums) {
        int len = nums.length;
        if (len <= 1) return len;
        int[] dp = new int[len]; 
        int[] counts = new int[len]; 

        //至少长度为1
        Arrays.fill(counts, 1);

        int maxLen = 0;

        for (int i = 0; i < len; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    if (dp[j] + 1 > dp[i]) {
                        dp[i] = dp[j] + 1;
                        counts[i] = counts[j];
                    }else if (dp[j] + 1 == dp[i]) {
                        counts[i] += counts[j];
                    }
                }
            }
            maxLen = Math.max(maxLen,dp[i]);
        }

        //通过比较maxLen，来进行个数的增加
        int res = 0;
        for (int i = 0; i < len; ++i) {
            if (dp[i] == maxLen) {
                res += counts[i];
            }
        }
        return res;
    }
}