XianKa

传送门

题意是说有n个问题，总共有m分。你如果想通过某个问题，你就需要复习大于该问题分数的时间。
但是你不知道每个问题是多少分。问题是你至少要复习多少时间才能保证通过至少K个问题。

解法是反向思考。

如果我是老师，那么我假设知道了学生的复习计划。那么我肯定会把他复习最多的 k – 1 个问题都设置为0分。这样我就有 m 分去尝试卡掉剩下的 n – k + 1 个问题。而这 n – k + 1 个问题也肯定是学生复习时间最少的几个问题。因为复习时间最长的 k – 1 个问题我已经设置为难度为0。

这也就是田忌赛马策略。

而对于剩下的 n – k + 1个问题。如果老师想都卡掉，那么最好的办法就是对于每一个问题，都设置为他复习时间那么多分，使得他刚刚无法通过。如果最后我 m 分刚好用完，或者还剩余。那么学生就被老师卡掉了。

反之，如果每道题设置复习时间那么多分数，m 分不够。那么学生就无法被卡掉。

这样看来，对于学生来说。只要最少的 n – k + 1 个复习时间，的总复习时间大于 m 那么就无法被卡掉。剩下的 k – 1 个时间都是大于最少的 n – k + 1 个复习时间的。那么这些时间一共最少是m + 1。（鸽巢原理，m 分放在 m + 1 的题上，总有一个题会过）

那么问题就变成了：有 n – k + 1 个数之和为 m + 1,且要求这些数里面最大的数字最小。

很明显这个最大的数字最小的时候就是平均分配 m + 1 分的时候。

所以，答案公式即ceil((m … Read the rest

传送门

题目是说给出n<=100个点，和每个点的权值。再由邻接矩阵的方式给出点之间的连通性。
问其中第k小的团的点权和是多少。团就是指的任意两点间都有直接路径联通的联通分量。

n k
V1 V2 .. Vn
string1
string2
..
stringK

输入
2 3
1 2
01
10
输出
2

首先，直接求前 k 大的团不好做，因为团的个数最多可以有2^{100}个。

所以可以转化为判断性问题，也就是说给定一个值 mid ，求再满足权值小于 mid 的情况下是否有 k 个或以上的团。由于k只有1e6，所以可以在搜索的时候进行可行性优化。

这也是常用的思想：将搜索前k大转化为二分判定问题。

想要在一个团的基础上找到下一个可能的点加入以后也成为团，只能暴力搜索。但是若每个点都判断一下和其他点是否联通复杂度会多n倍。

观察到每一行代表的是该点和其他点的连通性。例如第一行的01代表的就是1这个点和2是联通的。

那么需要想到的是，把任意m行的二进制数进行与运算，则得到的是和这m个数都联通的点，这样只要从这m个点里取就一定能形成一个团。

还需要对点权进行排序，加快搜索速度。排序后直接建立图：排名为 i 的点和排名为 j 的点的联通状态。搜索的时候每次取最低位就能保证相对团的大小是相对递增的。

100位的位运算可以用bitset，也可以用__int128

#include<bits/stdc++.h>
using namespace std;
const int maxn = 101;
typedef long long ll;
typedef __int128 lll;
typedef pair<int,int> pii;
const lll ONE = 1;
char s[maxn][maxn];
pii a[maxn];
lll G[maxn];
ll lmt, k, 

传送门

题目中有一个条件特别关键：1 ≤ a ≤ 1, 000

这说明二次函数全部开口向上。当x增大的时候，如果不能变得更小，只能变得更大。

所以把所有f(x=1)加入答案，取x=2下降最多的函数，同理取x=3,x=4…直到吧m用完为止

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 233;
typedef long long ll;
typedef pair<ll,ll> pii;
ll a[maxn], b[maxn], c[maxn];
set<pair<ll,pii> > st; // val, x, idx
int main()
{
    ll ans = 0;
    ll n, m; cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
        ans += a[i] + b[i] + c[i];
        st.insert({a[i] * 3 + b[i], {2, i}});
    

C传送门

题意是给定1-n的序列，附加n个0，每次a序列可以任意取出一张加入b序列尾部并且从b序列头部取出一张加入a序列。问最少多少步能完成排序。

分类贪心。第一类情况是b序列的尾部已经是一个完整的上升序列，并且a序列和b序列前部能顺序完成拼出上升序列，这种情况模拟一下，最后判断是否能成立。

另一种情况是必须把b序列取出一定的数。这种情况，对于每个取到的数子a[i] = k.他在第一个数字1加入a序列以后，最迟要在之后k步内取到，所以取如a序列的数字的步数就是tmp = max(tmp, i – a[i] + 1),在最大一个步数的数字取完后，就能保证顺序加入b序列的尾部时能完成排序，此时答案是tmp + n;因为加入n个数字需要n步。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 233;
int a[maxn], b[maxn], vis[maxn];
int n; 
int go()
{
    int ans = 0;
    for(int i = 1; i <= n; i++)
    {
        if(b[i]) ans = max(ans, i - b[i] + 1);
    }
    return ans + n;
}
int go2()
{
    set<int> st;
    for(int i = 1; i <= n; i++) if(a[i]) st.insert(a[i]);
    int ans 

传送门

题意是给定N个区间，询问M个区间最少能用多少个给定的线段覆盖，允许重合/超过。

首先很明显的是被某个区间完全覆盖的小区间是没有用的。

然后需要发现，对于每一个左端点，找到包含这个点而且右端点最远的一个区间肯定是最优解。

那么对于给定区间的右端点，按照降序排列。对排好序的每个区间 i ，这些点最远的右端点就是 i 这个区间的右端点。然后对于下一个区间 j ，小于上一个区间 i 左端点的那些点 的最远右端点就是当前区间 j 的右端点。

这样既消除了被完全覆盖的区间，又找到了包含每个点最远的区间。

然后按照上述关系建立图，实际上是一颗树。

对于每个询问[l, r]，通过树上倍增找到大于r最小的父亲。深度相减就是区间个数。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 233;
struct rec{int l, r;};
bool cmp(const rec &x, const rec &y)
{
    return x.r > y.r;
}
rec a[maxn], b[maxn];
int h[maxn], e[maxn], pre[maxn], cnt;
void add(int u, int v)
{
    e[cnt] = v; pre[cnt] = h[u]; h[u] = cnt++;
}
int mt[maxn];
int fa[maxn][20], d[maxn], t;
void 

A题

注意到横坐标和纵坐标其实是独立不影响的。只要知道了某一列有哪些连续的格子，就可以知道某一步应该走到哪里。这种思想在很多题目都出现过。

接下来变成了维护一些不相交区间，要支持快速查询某个点的左边和右边是否有区间，并且插入/合并区间。用set来实现。注意使用哨兵元素处理迭代器运算异常减少代码量。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 233;
char op[maxn];
typedef set<pair<int,int> > spi;
spi r[maxn], c[maxn];
void add(spi &s, int pos)
{
    int l = pos, r = pos;
    auto it = s.lower_bound({pos, pos});
    auto jt = it--; // jt: >=   it <=
    if(it->second == pos - 1) l = it->first;
    if(jt->first == pos + 1) r = jt->second;
    s.insert({l, r});
    if(l != pos) s.erase(it); 
    if(r != pos) s.erase(jt); 
}
void move(spi &s,