【LeetCode周赛一题选手】（2020.8.2）

最大得分

难度：困难

你有两个 有序 且数组内元素互不相同的数组 nums1 和 nums2 。

一条 合法路径 定义如下：

选择数组 nums1 或者 nums2 开始遍历（从下标 0 处开始）。
从左到右遍历当前数组。
如果你遇到了 nums1 和 nums2 中都存在的值，那么你可以切换路径到另一个数组对应数字处继续遍历（但在合法路径中重复数字只会被统计一次）。

得分定义为合法路径中不同数字的和。

请你返回所有可能合法路径中的最大得分。

由于答案可能很大，请你将它对 10^9 + 7 取余后返回。

示例 1：

输入：nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]
输出：30
解释：合法路径包括：
[2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],（从 nums1 开始遍历）
[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10]  （从 nums2 开始遍历）
最大得分为上图中的绿色路径 [2,4,6,8,10] 。

示例 2：

输入：nums1 = [1,3,5,7,9], nums2 = [3,5,100]
输出：109
解释：最大得分由路径 [1,3,5,100] 得到。

示例 3：

输入：nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]
输出：40
解释：nums1 和 nums2 之间无相同数字。
最大得分由路径 [6,7,8,9,10] 得到。

示例 4：

输入：nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]
输出：61

提示：

1 <= nums1.length <= 10^5
1 <= nums2.length <= 10^5
1 <= nums1[i], nums2[i] <= 10^7
nums1 和 nums2 都是严格递增的数组。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/get-the-maximum-score
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我的思路

其实还挺直接的，就以相同元素为界，分割数组。
对每段数组进行比对，取大，再加上关节。
就是细节东西多了点。

我的题解

class Solution {
public:
    int maxSum(vector<int>& nums1, vector<int>& nums2) {
        int count_all = 0;                  //总计数
        int count_part1 = 0, count_part2 = 0;  //部分计数
        int ptr1 = 0, ptr2 = 0;                //快慢指针

        int MAX = pow(10,9) + 7;
        int flag1 = 0,flag2 = 0;

        while (ptr1 < nums1.size() && ptr2 < nums2.size()) {
            
            if (nums1[ptr1] < nums2[ptr2]) {    //数组一中的元素小于数组二的
                count_part1 += nums1[ptr1];
                ptr1++;
                
                if(count_part1>MAX){
                    count_part1 -= MAX;
                    flag1++;
                }
            }
            else if (nums1[ptr1] > nums2[ptr2]) {//数组二中的元素大于数组一的
                count_part2 += nums2[ptr2];
                ptr2++;
                
                if(count_part2>MAX){
                    count_part2 -= MAX;
                    flag2++;
                }
            }
            else {     //两数组中元素重合
                count_all += max(count_part1, count_part2);
                count_all += nums2[ptr2];
                count_part1 = 0;
                count_part2 = 0;
                ptr1++;
                ptr2++;
            }

            while (count_all >= MAX) { //越界则进行删除
                count_all -= MAX;
            }
        }

        //如果有一组走到头了,另一组就把剩下的都加上
        while (ptr1 < nums1.size()) {
            if(count_part1>MAX){
                count_part1 -= MAX;
                flag1++;
            }
            count_part1 += nums1[ptr1];
            ptr1++;
        }
        while (ptr2 < nums2.size()) {
            if(count_part2>MAX){
                count_part2 -= MAX;
                flag2++;
            }
            count_part2 += nums2[ptr2];
            ptr2++;
        }
        
        if(flag1>flag2)
            count_all+=count_part1;
        else if(flag1<flag2)
            count_all+=count_part2;
        else
            count_all += max(count_part1, count_part2);

        if (count_all >= MAX) { //越界则进行删除
            count_all -= MAX;
        }
        
        return count_all;
    }
};

一小时就做了这么一题，失败了几次扣了点时间，剩下时间只够弄个第一题，太累了就没写。

我就想不明白那几个十几二十分钟就全做完的人得有多流弊。。。