校赛
1. 二分
小数
double l = 0,r = 100000,eps = 1e-4;
while (r-l >= eps){
double mid=(l+r)/2;
if (check(mid)) l=mid;
else r=mid;
}
整数
int l = 1,r = n,mid = (l+r)>>1;
while (l<r){
mid = (l+r+1)>>1;
if (check(mid)) l = mid;
else r = mid-1;
}
2. 并查集
O(logn)
int init(){
for (int i = 1;i <= n;i++) fa[i] = i;
}
int find(int x){
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void update(int x,int y){
int fu = find(x),fv = find(y);
fa[fu] = fv;
}
3. 递推
01背包
for (int i = 1;i <= n;i++) for (int j = m;j >= 0;j--) if (j >= w[i]) dp[j] = max(dp[j],dp[j-w[i]]+v[i]);
完全背包
for (int i = 1;i <= n;i++) for (int j = 0;j <= m;j++) if (j >= w[i]) dp[j] = max(dp[j],dp[j-w[i]]+v[i]);
多重背包
for (int i = 1;i <= n;i++) for (int j = m;j >= 0;j--) for (int k = 1;k <= num[i];k++){
if (j >= w[i]*k) dp[j] = max(dp[j],dp[j-k*w[i]]+k*v[i]);
}
多重背包的优化：把一个物品的不同个数（这里是\(2^n\)）看成是不同物品，然后01背包
int totlW = 0;
memset(w,0,sizeof w);
for (int i = 1;i <= n;i++){
for(int j = 1;j <= num[i];j <<= 1){
w[totlW++] = j * weight[i];
num[i] -= j;
}
if(num[i] > 0) w[totlW++] = num[i] * weight[i];
}
4. gcd
O(2log(max(a,b)))
int gcd(int a,int b){
if (!b) return a;
return gcd(b,a % b);
}
5. 最短路
Dij：Dij还可以用来计算多源最短路，只需要将每个起点都放入最初的队列
O(mlogn)
struct node{
int tot = 0;
int head[maxn],to[maxn],nxt[maxn];
long long w[maxn];
void add(int u,int v,int k){
to[++tot] = v,w[tot] = k,nxt[tot] = head[u],head[u] = tot;
}
}ed;
long long dis[maxn];
bool vis[maxn];
priority_queue<pair<long long,int> > q;
void Dij(){
for (int i = 1;i <= n;i++) dis[i] = inf,vis[i] = 0;
dis[s] = 0;
q.push(make_pair(0,s));
while (!q.empty()){
int x = q.top().second;q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = ed.head[x];i;i = ed.nxt[i]){
int to = ed.to[i];
if (dis[to] > dis[x] + ed.w[i]) {
dis[to] = dis[x] + ed.w[i];
q.push(make_pair(-dis[to],to));
}
}
}
}
SPFA：SPFA判负环，如果一个点入队n次则有负环
O(nm)
void SPFA(){
for (int i = 1;i <= n;i++) dis[i] = inf;
dis[s] = 0,vis[s] = 1;
q.push(s);
while (!q.empty()){
int x = q.front();q.pop();
vis[x] = 0;
for (int i = ed.head[x];i;i = ed.nxt[i]){
int to = ed.to[i],w = ed.w[i];
if (dis[to] > dis[x] + w){
dis[to] = dis[x] + w;
if (!vis[to]){
vis[to] = 1;
q.push(to);
}
}
}
}
}
Floyd
void Floyd(){
for (int k = 1;k <= n;k++)
for (int i = 1;i <= n;i++)
for (int j = 1;j <= n;j++) dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
}
6. 广度优先搜索
找最短路径，如果有特殊限制可能需要优先队列
7. 深度优先搜索
注意：多找剪枝的情况，记忆化搜索
8. 二分图匹配
O(顶点数*边数)
最大匹配：
int dfs(int x){
for (int i = 1;i <= k;i++){
if (!edge[x][i]) continue;
if (vis[i]) continue;
vis[i] = 1;
if (!match[i]||dfs(match[i])){
match[i] = x;
return 1;
}
}
return 0;
}
memset(match,0,sizeof(match));
for (int i = 1;i <= n;i++){
memset(vis,0,sizeof(vis));
if (dfs(i)) ans++;
}
最小点覆盖 = 最大匹配：选取最少的点，使得所有边都至少与一个被选取点相连
最大独立集 = 总点数 - 最大匹配：选取最多的点，使得其中任意两点互不相达
最小边覆盖 = 总点数 - 最大匹配：选取最少的边使得所有的点被至少一条边覆盖
9. 博弈
可以数学推导，也可以打表SG函数算
SG函数：先打表求出一定范围内每个小状态的SG值，发现规律后(发现不了规律可以硬算)，总状态的SG值为每个小状态的SG值的异或和，为0就是第一个人输了
map<pair<int,int>,int> mp;
int getSG1(int a,int b){
bool vis[maxn];
if (mp.count(make_pair(a,b))) return mp[make_pair(a,b)];
memset(vis,0,sizeof(vis));
for (int i = 1;i < a;i++) vis[getSG1(i,a-i)] = 1;
for (int i = 1;i < b;i++) vis[getSG1(i,b-i)] = 1;
for (int i = 0;i <= 10000;i++) if (!vis[i]){mp[make_pair(a,b)] = i;break;}
return mp[make_pair(a,b)];
}
10. 一些STL的用法
存储结构体要重载运算符
struct node{
int x = 0,y = 0;
bool operator < (const node &a)const{
if (x != a.x) return x < a.x;
return y < a.y;
}
}fig[maxn];
set 集合：有序不重复/unordered_set：只去重不排序/multiset：有序可重
s.insert();
s.clear();
set<int>::iterator it = s.find();
s.erase(s.find());//删除这个位置
s.erase(value);//删除一个值
s.erase(s.find(),s.find())//删除一个区间
s.size();
s.count();//某个值出现了多少次
set<int>::iterator it_low = st.lower_bound("i");//第一个大于等于
set<int>::iterator it_up = st.upper_bound("i");//第一个大于
for (set<int>::iterator it = s.begin();it != s.end();it++){
printf("%d ",*it);
}
map/unorderd_map/multimap
这里需要注意mulitmap只支持mp.insert(pair<int,string>(1,"ssss"));
if (mp.find(x) != mp.end())
11. 快速幂
int qpow(int x,int k){
int res = 1;
while (k){
if (k&1) (res *= x) %= mod;
(x *= x) %= mod;
k >>= 1;
}
return res % mod;
}
矩阵快速幂
可以用作dp优化，我们通常把dp[i]构造出一个\(n\times1\)的矩阵，转移矩阵为n\(\times\)n，如斐波那契：
struct mul{
long long a[maxn][maxn];
}a,I;
mul operator *(const mul &x,const mul &y){ //重载运算符
mul z;
memset(z.a,0,sizeof(z.a));
for (int k = 1;k <= n;k++)
for (int i = 1;i <= n;i++)
for (int j = 1;j <= n;j++)
z.a[i][j] = (z.a[i][j] + x.a[i][k]*y.a[k][j] % mod) % mod;
return z;
}
void qpow(long long k){
for (int i = 1;i <= n;i++) for (int j = 1;j <= n;j++) I.a[i][j] = 0;
for (int i = 1; i <= n;i++) I.a[i][i] = 1;
while(k){
if (k&1) I = I * a;
a = a*a;
k >>= 1;
}
}
12. 离散化
sort(que+1,que+1+cnt);
len = unique(que+1,que+cnt+1)-que-1;
for(int i = 1;i <= n;i ++){
s[i] = lower_bound(que + 1, que + len + 1, k[i]) - que;
}
