LeetCode 200场周赛

思路：

• 暴力。

class Solution {
public:
    int countGoodTriplets(vector<int>& arr, int a, int b, int c) {
        int cnt = 0;
        for(int i = 0; i < arr.size(); i++){
            for (int j = i + 1; j < arr.size(); j++){
                for (int k = j + 1; k < arr.size(); k++){
                    if ( (-a <= arr[i] - arr[j]) && (a >= arr[i] - arr[j])) 
                        
                    if ( (-b <= arr[j] - arr[k]) && (b >= arr[j] - arr[k])) 
                        
                    if ( (-c <= arr[i] - arr[k]) && (c >= arr[i] - arr[k])) 
                        cnt++;
                }
            }
        }
        return cnt;
    }
};

思路：

• 直接暴力模拟会超时。
• 这里使用指针快速遍历一遍数组就行。

class Solution {
public:
       
    int getWinner(vector<int>& arr, int k) {
        
        int win = 0;
        
        int index = -1;
        int temp;
        int cnt = 0;
        if (k == 1){
             if (arr[0] - arr[1] > 0) {
                 return arr[0];
             } else {
                 return arr[1];
             }
            
        }
        
        // int M = arr[0];
        // for (int i = 1; i < arr.size(); i++) {
        //     if (M < arr[i])
        //         M = arr[i];
        // }
        while (cnt <= arr.size() - 1){
            cnt++;
            
            if (arr[0] - arr[cnt] > 0) {
                
                win++;         
            } else {
                temp = arr[0];
                arr[0] = arr[cnt];
                arr[cnt] = temp;
                win = 1;
            }
            if (win == k){
                return arr[0];
            }
            
            
        }
        
        return arr[0];
    }
    
};

1536.排布二进制网格的最少交换次数

思路：

• 由于只能是行的交换所以，对于每一行的0和1的位置并不发生改变。
• 第一行的后缀0只能是在第2个
• 第二行的后缀0只能是在第3个
• ...
• 寻找最符合的后缀0的位置 当前行符合就跳过 不符合就去找最近符合的 并记录交换次数
• 找不到则直接返回-1

class Solution {
public:
    int minSwaps(vector<vector<int>>& grid) {
        int n = grid.size(); //网格规模
        vector<int> a; //记录每一行后缀0个数的数组
        for(int i = 0; i < n; i++)
        {
            int count = 0;
            for(int j = n - 1; j >= 0; j--)
            {
                if(grid[i][j] == 0) count++; //数每一行的后缀0
                else break;
            }
            a.push_back(count); 
        }
        int count = 0; //交换次数
        for(int i = 0; i < n - 1; i++)
        {
            if(a[i] >= n - i - 1) continue;//满足条件，该行直接跳过
            else{//不满足条件
                int j = i; //用新参数遍历找满足条件的后缀0
                for(; j < n; j++)
                {
                    if(a[j] >= n - i - 1) break;
                }
                if(j == n) return -1; //找不到，直接返回-1
                for(; j > i; j--) //找到了最先满足条件的后缀0个数 
                {
                    swap(a[j], a[j - 1]); //每一行交换上去
                    count++; //记录交换次数
                }
            }
        }
        return count;
    }
};

思路：

相交点可以将2个数组都分成(K + 1)段，统计每段的和，并取较大值计入结果，可以用双指针快速实现。

int maxSum(vector<int>& nums1, vector<int>& nums2) {
        long sum1 = 0, sum2 = 0;
        long res = 0;
        int i = 0, j = 0;
        while(i < nums1.size() && j < nums2.size()){
            if(nums1[i] == nums2[j]){
                res += (max(sum1, sum2) + nums1[i]);
                sum1 = 0;
                sum2 = 0;
                i++;
                j++;
            }
            else if(nums1[i] < nums2[j]){
                sum1 += nums1[i];
                i++;                
            }
            else{
                sum2 += nums2[j];
                j++;
            }            
        }
        while(i < nums1.size()){
            sum1 += nums1[i];
            i++;
        }
        while(j < nums2.size()){
            sum2 += nums2[j];
            j++;
        }
        res += max(sum1, sum2);
        return res % ((int)pow(10, 9) + 7 );
}