教算法么？

我不太懂，要问老师

c++教吗😊

没啥时间了，我家娃儿准备开学了

七天可以学什么

暑假过了，不学了

我可以远程一对一教c++和算法竞赛

我教算法竞赛

私信发一下你的个人简介和收费之类的信息

孩子学过初级算法，麻烦私发一下收费价格和个人简介

发一个我的USACO编程竞赛讲稿
本讲稿适合准备参加美国计算机奥林匹克竞赛USACO，加拿大计算机竞赛CCC的学生阅读。默认阅读者已经学过编程语言，最好是C++。
本讲稿覆盖USACO涉及的大部分算法/数据结构/技巧，分成基础，铜组(Bronze division),银组(Silver division),金组(Gold division),白金组(Platinum division)五部分。

学习算法不只是提高你的编程水平，而是培养你解决问题的能力，这种能力也有益于别的领域/学科。Thinking twice,coding once.在你开始敲代码前先仔细想清楚你的思路(算法)。

算法竞赛是在限定的时间内写代码来解决问题，然后把你的代码提交给评测系统，评测系统事先准备好若干组输入数据和相应的输出数据作为测试点test case，把输入数据喂给选手的程序，在限定的时间(通常2s)和内存(通常256M)范围内产生出结果，把输出结果与测试点比较，一致就得分，即“黑盒测试”。

算法竞赛和软件开发不一样，不要求可维护性，不需要注释/文档，只要编程快(算法易实现)，运行快，结果正确，只要你自己可读就行(只在比赛时可读)。

USACO每个赛季举办4次比赛：12月，1月，2月，US open(3月)。一般是4小时(US open是5小时)完成3道题，总分是1000分，每题333分(如果有15个测试点，每个测试点22分),总得分达到一定分数线就晋级，

练习时选择适合自己水平的题目，所谓适合自己水平，就是需要费劲思考才有解决方案，或者只能得大部分分数，剩余的小部分测试点只能看题解。如果你一看题目就知道怎么解决，这是太简单了。如果你只能得0分或少数分，那对你来说太难了。一般铜组题目思考15-20分钟还一无所获，银组题目思考30-40分钟还没有思路，那就可以看题解了；看别人的题解时先看一点点前面的提示，如果这时自己恍然大悟，就不要继续往下看了，而应该试着自己完成剩余部分。

一、基础知识
1.1尽量使用C++语言
C++是使用最广泛的参赛语言/题解语言。参赛所用C++只是C++语言的一个小子集，只是C语言加上标准模板库STL。
虽然在USACO，Python、Java时间限制是C++的两倍(4s)，但还是C++程序运行更快，更易于满足时间限制。白金组使用Python有些测试点可能会超时。

在2020年12月之前，USACO采用文件输入输出，如下：
#include <cstdio>
using namespace std;

int main(){
        freopen("problem-name.in","r",stdin);
        freopen("problem-name.out","w",stdout);
        。。。
}
在2020年12月之后，USACO采用标准输入输出。
使用cin/cout时，可以main开头用”  ios::sync_with_stdio(false); cin.tie(0); “取消C和C++ I/O流的同步，取消cin之前先完成输出，加速读写。
输出结果时不要在末尾输出额外的空格或空行。例如：
cout << "ans" << " "; cout << "ans" << "\n\n";
尽量把数组声明为全局，它会自动初始化为0.
USACO可以使用万能头文件。如下：
#include <bits/stdc++.h>
可以多次提交你的代码，以最后一次提交的为准。
在你的本机编译环境设置里加："-O2" 优化加速， "-std=c++11"支持C++11, 还可以加：-Wall -Wextra -Wshadow -Wconversion -Wfloat-equal -Wduplicated-cond -Wlogical-op

#define MOD 1e9 + 7
int main() {
        cout << int(MOD) << "\n"; // 1000000007
        cout << int(MOD*2) << "\n"; // 1000000014
        cout << int(2*MOD) << "\n"; // 2000000007
}
const int MOD = 1e9 + 7;

#define ll long long
int main() { cout << ll(1e18); }
// using ll = long long;

常用5种数据类型：
32位整数int，范围大约是-2e9~+2e9;
64位整数long long,范围大约是-9e18~+9e18.竞赛时long long一般就够用，如果有时数据太大，会让你把数据模%一个质数。scanf, printf涉及long long时用"%lld"
双精度浮点数double，注意:计算机算出来的浮点数有一点的精度/误差，所以比较时不能用“==”。USACO题目会要求你把结果乘以某数(比如1e6)后取整，或者评测系统会认为一定范围内的小数都正确。
布尔变量bool,可以用作函数返回值标记成功或失败，可以用一个布尔数组来标记节点有没被处理过。
字符char， 对应 ASCII码，('f'-'a')结果是5.
字符串string, 字符串问题在USACO中通常很简单，不需要特殊数据结构。

1.2时间复杂度
USACO给C++程序的时间限制一般是2s，评测系统可以跑5e8(如果你的常数足够优秀).
时间复杂度是指该程序/算法所做操作的步数的上限，用数据规模的函数来表示O(f(n)).其中已忽略常数和低次项。例如O(n):
for (int i = 1; i <= 5 * n + 17; i++) {
        // constant time code here
}
O(n^2):忽略低次项
for (int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
                // constant time code here
        }
}
for (int i = 1; i <= n + 58834; i++) {
        // more constant time code here
}

O(n^2):考虑最坏情况
for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
                // constant time code here
        }
}
二分搜索O(log n)
Ordered set/map or priority queue 每个操作O(log n)
分解质因数,质数判定O(n^1/2)
排序O(n log n)  n<=5e5
遍历n个数的所有子集O(2^n)
遍历n个数的全排列 O(n!)    n<=10

1.3 竞赛常用的STL
数据结构决定数据如何存储/排序/索引，支持什么操作。 各有所长。都支持.size(),.empty()

Iterator像指针，用来遍历container内所有元素。
for (vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it) {
        cout << *it; //prints the values in the vector using the pointer
}
更常用的是：
for(auto element : v) {
        cout << element; //prints the values in the vector
}

vector可变长数组
vector<int> v;
for(int i = 1; i <= 10; i++){
        v.push_back(i);  //末尾删加O(1)
}
vector<int> v(30); //initial size 30
v.erase(v.begin(), v.begin()+3); //删v[0],v[1],v[2],后面的往前挪，O(n)
v.erase(v.end()-1);
sort(v.begin(), v.end()),

for(int i = 0; i < v.size(); i++){
        cout << v << " ";
}
cout << endl;
int arr[] = {1, 7, 4, 5, 2};
for(int element : arr){
        cout << element << " ";
}

stack堆栈 LIFO
stack<int> s;
s.push(1);
cout << s.top() << endl;
s.pop()

queue队列 FIFO  O(1)
queue<int> q;
q.push(1);
q.pop();
cout << q.front() << endl;

deque双头队列
deque<int> d;
d.push_front(3); // [3]
d.push_back(7); // [3, 7]
d.pop_front(); // [7]
d.pop_back();

priority_queue优先队列 大根堆 删加取O(log n)
priority_queue<int> pq;
pq.push(7); // [7]
pq.push(2); // [7,2]
pq.push(5); // [7,x,x]
cout << pq.top() << endl; // 7
pq.pop(); // [5,2]

set无重复，map的key无重复，valve可重复
unordered_set<int> s;  //哈希hashing, O(1) 常数大
s.insert(2); // [2]
cout << s.count(2) << endl; // 1
set.erase(2); //
for(int element : s){
        cout << element << " "; //遍历顺序随机
}

set<int> s;   //删加取O(log n);不擅长:找第k大的数，比x大的数有多少
s.insert(1); // [1]
s.insert(14); // [1, 14]
s.insert(9); // [1, 9, 14]
s.insert(2); // [1, 2, 9, 14]
cout << *s.upper_bound(7) << \n; // 9
cout << *s.upper_bound(9) << \n; // 14  >9
cout << *s.lower_bound(5) << \n; // 9
cout << *s.lower_bound(9) << \n; // 9   >=9
cout << *s.begin() << \n; // 1
auto it = s.end();
cout << *(--it) << \n; // 14
s.erase(s.upper_bound(6));// [1, 2, 14]  >6

unordered_map<int, int> m; //删加取O(1),哈希hashing, 常数大
m[1] = 5; // [(1, 5)]
m[3] = 14; // [(1, 5); (3, 14)]
m[2] = 7; // [(1, 5); (3, 14); (2, 7)]
m.erase(2); // [(1, 5); (3, 14)] .erese(key) .erase(iterator)
cout << m[1] << \n; // 5
cout << m.count(7) << \n ; // 0 the nbr of key=7

map<int, int> m;
m[3] = 5; // [(3, 5)]
m[11] = 4; // [(3, 5); (11, 4)]
m[10] = 491; // [(3, 5); (10, 491); (11, 4)]
cout << m.lower_bound(10)->first << " " << m.lower_bound(10)->second << \n; // 10 491
cout << m.upper_bound(10)->first << " " << m.upper_bound(10)->second << \n; // 11 4
m.erase(11); // [(3, 5); (10, 491)]
if (m.upper_bound(10) == m.end())
{
        cout << "end" << endl; // Prints end
}

multiset<int> ms;  //O(log n + f)
ms.insert(1); // [1]
ms.insert(14); // [1, 14]
ms.insert(9); // [1, 9, 14]
ms.insert(2); // [1, 2, 9, 14]
ms.insert(9); // [1, 2, 9, 9, 14]
cout << ms.count(4) << \n; // 0