挑战程序设计竞赛第一章 笔记

第一章 蓄势待发：准备篇

常见的评测结果

结果	说明
Accepted, AC	单点测试，没通过一组数据，就会返回一个Accepted；多点测试只有通过所有的数据之后，才会返回一个Accepted。
Compile Error, CE	代码没有通过编译，看本地编译器能不能通过代码，修改之后再提交。
Wrong Answer, WA	代码有漏洞或者算法就是错的。
Time Limit Exceeded, TLE	运行时间超过允许上限。死循环的情况最常见
Running Error, RE	造成这一错误的可能性很多：非法访问内存，浮点错误，递归爆栈等。
Memory Limit Exceeded, MLE	一般数组太大会导致这个问题
Presentation Error, PE	最接近Accepted的错误，一般由多输出空格或者换行导致。
Output Limit Exceeded,OLE	一般由输出了大量调试信息或者特殊数据导致死循环输出导致。

1.5 以高效的算法为目标

由数据范围反推算法复杂度以及算法内容

1.6 轻松热身

611. 有效三角形的个数

能够构成三角形的条件是任意两边之和>第三边
（1）BF暴力枚举，时间复杂度O(n³) n<=1000 超时

（2）排序+ 二分查找，时间复杂度O(n²logn之间)

将数据排好序之后，利用两个指针i，j指向三角形的两条边，此时由于数据已经有序，那么只需要找到<(nums[i] + nums[j])的最后一个元素即可，假设找到的数组元素的下标为k，那么nums[j+1…k]之间的元素，都可以和nums[i]、nums[j]构成三角形

class Solution {
    vector<int> nums;
public:

    int triangleNumber(vector<int>& nums) {
        this->nums = nums;
        int n = nums.size(), res = 0;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < n; i++){
            for (int j = i+1; j < n; j++){
                int low = j+1, high = n, target = nums[i] + nums[j];
                //二分查找>=target的第一个元素所在的位置, low-1就是<target的最大下标
                while(low < high){
                    int mid = (low + high) / 2;
                    if (nums[mid] >= target){
                        high = mid;
                    }else
                        low = mid+1;
                }
                if (low-1 > j)  //low-1就是<target的元素的最后一个位置
                    res += low-j-1;
            }
        }
        return res;
    }
};


```c++
class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        int res = 0, n = nums.size();
        sort(nums.begin(), nums.end());
        for (int i = 0; i < n; i++){
            for (int j = i+1; j < n; j++){
                //返回>=nums[i]+nums[j]的以一个位置
                int k = lower_bound(nums.begin() + j, nums.end(), nums[i] + nums[j]) - nums.begin();
                if (k > j)
                    res += k-j-1;
            }
        }
        return res;
    }
};

（3）排序 + 双指针

nums[i]固定，随着nums[j]的增加，nums[k]也会增加，固定i让j和k右移，每次k移动到最右边

算法的时间复杂度O(n²)

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        int n = nums.size(), res = 0;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < n-2; i++){
            for (int j = i+1, k = i+2; j < n-1; j++){
                while(k < n && nums[k] < nums[i] + nums[j]) k++;
                res += max(k-j-1, 0);
            }
        }
        return res;
    }
};

1503. 所有蚂蚁掉下来前的最后一刻

tag:脑筋急转弯

1. 两数之和

（1）暴力搜索，算法的时间复杂度O(n²)

（2）哈希表，算法的时间复杂度O(n)

利用一个哈希表来存储数组中的值和对应的下标，这里需要注意的是必须是数组中两个不同的下标，所以需要在判断条件上额外添加

i != mp[target - nums[i])]

（3）排序 + 双指针
时间复杂度O(nlogn)

15. 三数之和

n = 3000，用暴力可能会超时，可以根据题意添加一些条件来减少不必要的判断

（1）暴力，算法的时间复杂度O(n³)，超时

（2）排序 + 二分查找，算法的时间复杂度O(n²log₂n)

（3）排序 + 双指针 + 优化 算法的时间复杂度 < O(n²)

（3）排序 + 哈希表 + 优化 同上

（4）DFS （只是为了锻炼代码，超时）

18. 四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<vector<int>> res;
        for (int i = 0; i + 3 < n; i++){
            if (i && nums[i] == nums[i-1])  continue;
            if ((long long)nums[i] + nums[i+1] + nums[i+2] + nums[i+3]  > target)
                break;
            for (int j = i+1; j + 2 < n; j++){
                if (j > i+1 && nums[j] == nums[j-1])   continue;
                if ((long long)nums[i] + nums[j] + nums[j+1] + nums[j+2]> target)
                    break;
                for (int k = j+1, l = n-1; k < l;){
                    if (k > j+1 && nums[k] == nums[k-1]){
                        k++;
                        continue;
                    }
                    long long sum = nums[i] + nums[j] + nums[k] + nums[l];
                    if (sum == target){
                        res.push_back({nums[i], nums[j], nums[k], nums[l]});
                        k++, l--;
                    }else if (sum >target){
                        l--;
                    }else
                        k++;
                }
            }
        }
        return res;
    }
};