题目：
https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/
这道题有点贪心？最优规划？动态规划？我也不知道叫啥了。
就是从前往后算，后者的计算需要用到前者的值
原本想法，找到各个点的当前最长长度，找到最长的几个值，然后倒推，后来觉得倒推太费时间，能不能在取最长值的时候，就把解拿到
就有了下面的代码
如果只要求最长长度
只需要int[] maxs = new int[len];
但是现在要可能性再加一个数组int[] anss = new int[len];

代码：

public int findNumberOfLIS(int[] nums) {
    int len = nums.length;
    if (len == 0) {
        return 0;
    }
    //最大值
    int[] maxs = new int[len];
    //当取最大值时的可能性个数
    int[] anss = new int[len];
    //所有的最大长度
    int maxLen = 1;
    int ans = 1;
    maxs[0] = 1;
    anss[0] = 1;
    for (int i = 1; i < len; i++) {
        maxs[i] = 1;
        anss[i] = 1;
        for (int j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                if (maxs[j] + 1 < maxs[i]) {
                    continue;
                }
                if (maxs[j] + 1 == maxs[i]) {
                    //计数不是+1，而是加上所有的可能性
                    anss[i] += anss[j];
                    continue;
                }
                if (maxs[j] + 1 > maxs[i]) {
                    //如果当前的值更大，重新计数
                    maxs[i] = maxs[j] + 1;
                    anss[i] = anss[j];
                }
            }
        }
        if (maxs[i] > maxLen) {
            //如果maxLen更大了，重新计数
            maxLen = maxs[i];
            ans = anss[i];
            continue;
        }
        if (maxs[i] < maxLen) {
            continue;
        }
        if (maxs[i] == maxLen) {
            ans += anss[i];
            continue;
        }
    }
    return ans;
}