边走边维护 一定要会的技巧

边走边维护，就是说，有时候你需要两层循环或循环两次才能做的一件事，你只用一次循环直接做完。

比如 求一个数组里面最大的两个数和

 

class Solution {
public:
    int maxScoreSightseeingPair(vector<int>& values) {
        int ans = 0, mx = values[0] + 0;
        for (int j = 1; j < values.size(); ++j) {
            ans = max(ans, mx + values[j] - j);
            // 边遍历边维护
            mx = max(mx, values[j] + j);
        }
        return ans;
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/best-sightseeing-pair/solution/zui-jia-guan-guang-zu-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

 

    public int helper2(int[] nums, int index) {
        int[] dp = new int[nums.length];
        int ans = 0;
        Arrays.fill(dp,1);
        cnt[nums.length-1] = 1;

        for(int i = nums.length-2; i >= 0; i--) {
            for(int j = i+1; j<nums.length; j++) {
                if(nums[i] < nums[j]) dp[i] = Math.max(dp[i],1+dp[j]) ;
                
            }
            cnt[i] = 0;
            for(int j = i+1; j<nums.length; j++) {
                if(dp[i] == dp[j]+1 && nums[i] < nums[j]) cnt[i]+=cnt[j];
            }
            cnt[i] = cnt[i] > 0 ? cnt[i] : 1;
            maxlen = Math.max(dp[i],maxlen);
        }

        for(int i = 0;i < nums.length; i++) {
            if(dp[i] == maxlen) {
                ans+=cnt[i];
            }
        }
        return ans;
    }
}

class Solution {
    public int findNumberOfLIS(int[] nums) {
        int n = nums.length, maxLen = 0, ans = 0;
        int[] dp = new int[n];
        int[] cnt = new int[n];
        for (int i = 0; i < n; ++i) {
            dp[i] = 1;
            cnt[i] = 1;
            for (int j = 0; j < i; ++j) {
                if (nums[i] > nums[j]) {
                    if (dp[j] + 1 > dp[i]) {
                        dp[i] = dp[j] + 1;
                        cnt[i] = cnt[j]; // 重置计数
                    } else if (dp[j] + 1 == dp[i]) {
                        cnt[i] += cnt[j];
                    }
                }
            }
            if (dp[i] > maxLen) {
                maxLen = dp[i];
                ans = cnt[i]; // 重置计数
            } else if (dp[i] == maxLen) {
                ans += cnt[i];
            }
        }
        return ans;
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/number-of-longest-increasing-subsequence/solution/zui-chang-di-zeng-zi-xu-lie-de-ge-shu-by-w12f/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

思想就是 我平常喜欢把东西都处理好了再分配应该分配的东西。

这个就是 边处理边分配，尤其是找最大东西