[2021省选板刷]
作者：互联网
绿色的话主要是自己想出来的，红色的是看了题解的
真就啥都不会。。。
\({\color{red}{「九省联考 2018」一双木棋}}\)
前置知识：\(minmax搜索\)：
两方都采取最优策略，问我方的最终结果，轮到我方采取对答案贡献最大的，敌方采取对答案贡献最小的搜索方案
考虑用\(vector\)记录每一列放了多少棋子
记忆化搜索完全可以*过去
#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
#define ll long long
using std::vector;
using std::map;
map<vector<int>,int>f;
vector<int>h;//状态总数
inline ll read(){
char a = getchar();
ll ans = 0,o = 1;
while(a != '-' && (a < '0' || a > '9'))
a = getchar();
if(a == '-')
o = -1,a = getchar();
while(a <= '9' && a >= '0')
ans = (ans << 3) + (ans << 1) + (a - '0'),a = getchar();
return ans * o;
}
ll n,m;
int A[12][12],B[12][12];
ll inf = 0x7f7f7f7f;
int dfs(int turn){//对抗搜索
if(f.find(h) != f.end())return f[h];
int ans = turn ? -inf : inf;
for(int i = 0;i < n;++i){
if((i == 0 || h[i - 1] > h[i]) && h[i] < m){
++h[i];
if(turn)
ans = std::max(ans,dfs(0) + A[i + 1][h[i]]);
else
ans = std::min(ans,dfs(1) - B[i + 1][h[i]]);
--h[i];
}
}
return f[h] = ans;
}
int main(){
n = read(),m = read();
for(int i = 1;i <= n;++i)
for(int j = 1;j <= m;++j)
A[i][j] = read();
for(int i = 1;i <= n;++i)
for(int j = 1;j <= m;++j)
B[i][j] = read();
for(int i = 0;i < n;++i)
h.push_back(m);
f[h] = 0;//无路可走自然是0
for(int i = 0;i < n;++i)
h[i] = 0;
std::cout<<dfs(1);
}
虽说不开\(-o2\)只有\(80\),但我要是在这次省选里能做到这步也就不错了
[九省联考2018]IIIDX
\({\color{green}{subtask1}}\)无重复数据
考虑每个点只有一个前缀，那么显然构成一颗树形结构。
我们先把这颗树建出来，那么作为父节点要小于每个子节点的值。
那么我们考虑贪心，把更大一点的值留给子节点。
注意一个点：按照我的建边方法，需要从后往前建点，因为对于并列的点来说，我们递归进子树，先遍历的一颗子树的权值会更大。
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define ll long long
#define N 500005
ll n;
double k;
ll v[N],top;
struct P{
int to,next;
}e[4 * N];
int cnt,head[N],ans[N];
void add(int x,int y){
e[++cnt].to = y;
e[cnt].next = head[x];
head[x] = cnt;
}
ll root;
void dfs(int u){
for(int i = head[u];i;i = e[i].next){
int v = e[i].to;
dfs(v);
}
if(u != root)
ans[u] = v[top--];
}
int main(){
scanf("%lld",&n);
scanf("%lf",&k);
for(int i = 1;i <= n;++i)
scanf("%lld",&v[i]);
std::sort(v + 1,v + n + 1);
root = n + 1;
top = n;
for(int i = n;i >= 1;--i){
int dad = i / k;
dad = dad ? dad : root;
add(dad,i);
}
dfs(root);
for(int i = 1;i <= n;++i)
printf("%d ",ans[i]);
}
\({\color{red}{subtask2}}\)有重复数据
那么明显我们第一档的贪心是不满足答案的
我们考虑从小到大排序，那么根据我们的字典序最优法则
字典序最大的一类题目：
正解则是考虑按位确定：考虑从 \(1\) 到 \(n\) 依次确定该点选了哪个值，确定 i 这个位置的值时，我们选取满足以下条件的值：
- 使得这个东西确定之后，存在一种 \(i+1\) 到 \(n\) 的分配方案，使得总方案合法。
- 尽可能大。
我们考虑如何判断在这一位选定的数\(x\),我们要使大于等于\(x\)的数的数量大于等于\(siz_i\)
这个时候我们记\(f_i\)为大于第\(i\)个数的数量
考虑进行二分求解\(x\)
这个时候在\(1~n\)全局减去\(siz_x\)（先给子树站好位置，防止其他的父亲抢儿子）
如果遇到了\(i\)的儿子，那么在\(res[fa[i]] ~ n\)上加回\(siz_x\)（拿回位置，由于子树是连续一串，所以不会影响贡献）
\(f_i\)在操作过程中可能不再满足单调性，但这是由于我们是按位确定，确定完父亲后并不能判断后续儿子的情况，实际上\(f_i\)是会满足单调性的
那么我们进行一个取\(min\)操作，操作得到的数就是最好情况下\(f_i\)最多的值
代码鸽了。
\({\color{red}{[九省联考2018]秘密袭击coat}}\)
考虑对每个点进行处理，对于一个点来说，他只有两种选择，选入联通块或者不。
记录\(f_{i,j}\)为当前处理\(S\)是\(s->i\)路径上联通块中排名为\(j\)的联通块方案数
#include<bits/stdc++.h>
#define ll long long
#define N 2000
#define mod 64123
int n,k,w;
int d[N];
int f[N][N],ans;
struct P{
int to,next;
}e[N << 1];
int cnt,head[N];
void add(int x,int y){
e[++cnt].to = y;
e[cnt].next = head[x];
head[x] = cnt;
}
ll S;
inline int read(){
char a = getchar();
int ans = 0,f = 1;
while(a != '-' && (a < '0' || a > '9'))
a = getchar();
if(a == '-')
f = -1,a = getchar();
while(a <= '9' && a >= '0')
ans = (ans << 3) + (ans << 1) + (a - '0'),a = getchar();
return ans * f;
}
void dfs(int x,int fa){
if(d[x] > d[S] || (d[x] == d[S] && x < S))//在集合里选上这个点的贡献
for(int i = 1;i < k;++i)
f[x][i + 1] = f[fa][i];
else
for(int i = 1;i <= k;++i)
f[x][i] = f[fa][i];
for(int i = head[x];i;i = e[i].next){
int v = e[i].to;
if(v == fa)
continue;
dfs(v,x);
}
for(int i = 1;i <= k;++i)//更新父亲，此时相当于父亲不选
f[fa][i] = (f[fa][i] + f[x][i]) % mod;
}
int main(){
n = read(),k = read(),w = read();
for(int i = 1;i <= n;++i)
d[i] = read();
for(int i = 1;i < n;++i){
int x = read(),y = read();
add(x,y);
add(y,x);
}
for(int i = 1;i <= n;++i){
S = i;
int tot = 0;
for(int j = 1;j <= n;++j){
if(d[j] > d[i] || (d[j] == d[i] && i > j))
tot ++ ;
}
if(tot < k - 1) continue;
std::memset(f,0,sizeof(f));
f[i][1] = 1;
for(int j = head[i];j;j = e[j].next)
dfs(e[j].to,i);
ans = (ans + 1ll * f[i][k] * d[i]) % mod;
}
printf("%lld\n",ans);
}
\({\color{red}{[九省联考2018]劈配}}\)
首先第一档\(d = 1\)明显乱做。。
考虑对每个点每一档的老师都连边，跑网络流，如果有流量那么这一档可以，否则删掉这些老师的边，下一档
如果找到老师，那么对每个老师都和源点连边，如果还有流量，那么证明这个老师其实还有一种方案可以让他选择，所以记录每个老师最后的有方案选择的时间就行了
代码鸽了
\([八省联考2018]林克卡特树\)
题意：大概意思是求树上\(k + 1\)条链的最大和
\({\color{green}{60分}}\)
其实不能全算自己想出来的，对于这类树上的链有经典做法，今天才算学到。
\(f[u][j][0/1/2]\)代表\(u\)中有\(j\)条完整的链，\(0\)是该子树的最优答案，\(1\)是以\(u\)为起点的一条链（这是唯一的不是完整的链的情况），\(2\)是\(u\)处于一条链的中心。
转移看代码。
#include<bits/stdc++.h>
#define ll long long
#define N 300005
#define K 200
int n,k;
int f[N][K][3];
struct P{
int to,next,v;
}e[N << 1];
int head[N],cnt;
void add(ll x,ll y,ll v){
e[++cnt].to = y;
e[cnt].next = head[x];
e[cnt].v = v;
head[x] = cnt;
}
void dfs(int u,int fa){
f[u][0][0] = f[u][0][1] = f[u][1][2] = 0;
for(int i = head[u];i;i = e[i].next){
int v = e[i].to;
if(v == fa)
continue;
dfs(v,u);
for(int j = k;j;--j){
f[u][j][1] = std::max(f[u][j][1],f[u][j][0] + f[v][0][1] + e[i].v);
for(int l = j - 1;~l;--l){
f[u][j][0] = std::max(f[u][j][0],f[u][l][0] + f[v][j - l][0]);
f[u][j][1] = std::max(f[u][j][1],std::max(f[u][l][1] + f[v][j - l][0],f[u][l][0] + f[v][j - l][1] + e[i].v));
f[u][j][2] = std::max(f[u][j][2],std::max(f[u][l][2] + f[v][j - l][0],f[u][l][1] + f[v][j - l - 1][1] + e[i].v));
}
}
f[u][0][1] = std::max(f[u][0][1],f[v][0][1] + e[i].v);
}
for(int i = 1;i <= k;++i)
f[u][i][0] = std::max(f[u][i][0],std::max(f[u][i - 1][1],f[u][i][2]));
}
int main(){
scanf("%d%d",&n,&k),++k;
for(int i = 1;i < n;++i){
ll x,y,v;
scanf("%lld%lld%lld",&x,&y,&v);
add(x,y,v);
add(y,x,v);
}
memset(f,~0x3f,sizeof(f));dfs(1,0);
std::cout<<f[1][k][0]<<std::endl;
}
\({\color{red}{WQS二分}}\)
前置芝士：wqs二分
看到这类限制取\(m\)个的最大值或者最小值，如果没有\(m\)限制的\(dp\)复杂度很低，而且关于原\(dp\)是一个凸函数考虑\(wqs二分\)
看完上面那个博客就知道该怎么写了
#include<bits/stdc++.h>
#define reg register
typedef long long ll;
using namespace std;
const int MN=3e5+5;
int to[MN<<1],nxt[MN<<1],c[MN<<1],h[MN],cnt;
inline void ins(int s,int t,int w){
to[++cnt]=t;nxt[cnt]=h[s];c[cnt]=w;h[s]=cnt;
to[++cnt]=s;nxt[cnt]=h[t];c[cnt]=w;h[t]=cnt;
}
#define chkmax(a,b) ((a)<(b)?(a)=(b):0)
int n,k;
ll l,r,mid;
struct data{
ll val;int pos;
data(ll x=0,int y=0):val(x),pos(y){}
friend bool operator<(data a,data b){
ret###${\color{red}{WQS二分}}$urn a.val==b.val?a.pos>b.pos:a.val<b.val;
}
friend data operator+(data a,data b){
return data(a.val+b.val,a.pos+b.pos);
}
friend data operator+(data a,ll b){
return data(a.val+b,a.pos);
}
}f[MN][3],tmp;
int fa[MN];
void getf(int st){
for(reg int i=h[st];i;i=nxt[i])
if(to[i]!=fa[st])fa[to[i]]=st,getf(to[i]);
}
void dfs(int st){
f[st][0]=f[st][1]=f[st][2]=data();
chkmax(f[st][2],tmp);
for(reg int i=h[st];i;i=nxt[i]){
if(to[i]==fa[st])continue;dfs(to[i]);
chkmax(f[st][2],max(f[st][2]+f[to[i]][0],f[st][1]+f[to[i]][1]+c[i]+tmp));
chkmax(f[st][1],max(f[st][1]+f[to[i]][0],f[st][0]+f[to[i]][1]+c[i]));
chkmax(f[st][0],f[st][0]+f[to[i]][0]);
}
chkmax(f[st][0],max(f[st][1]+tmp,f[st][2]));
}
int main(){
scanf("%d%d",&n,&k);k++;
for(reg int i=1,s,t,w;i<n;i++)
scanf("%d%d%d",&s,&t,&w),ins(s,t,w);
l=-1e12;r=1e12;getf(1);
while(l<r){
mid=(double)(l+r)/2-0.5;
tmp=data(-mid,1);dfs(1);
if(f[1][0].pos==k){
printf("%lld\n",f[1][0].val+mid*k);
return 0;
}
if(f[1][0].pos>k)l=mid+1;
else r=mid;
}
mid=l;tmp=data(-mid,1);dfs(1);
printf("%lld\n",f[1][0].val+mid*k);
return 0;
}
\({\color{red}{[十二省联考2019]}}{\color{green}{[春节十二响]}}\)
为啥是双色的？
S-我想到了启发式合并，没仔细想具体过程。
考虑两条链的合并，把两条链丢进堆里，只保留两条链的最大值进结果链，再把较长的链的最后部分塞进结果链
考虑直接把长链当做结果链，那么考虑启发式合并。
解决
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 6;
int n, a[N], f;
vector<int> e[N], o;
priority_queue<int> q[N];
inline void merge(int x, int y) {
if (q[x].size() < q[y].size()) swap(q[x], q[y]);
while (q[y].size()) {
o.push_back(max(q[x].top(), q[y].top()));
q[x].pop(), q[y].pop();
}
while (o.size()) q[x].push(o.back()), o.pop_back();
}
void dfs(int x) {
for (unsigned int i = 0; i < e[x].size(); i++)
dfs(e[x][i]), merge(x, e[x][i]);
q[x].push(a[x]);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) scanf("%d", &f), e[f].push_back(i);
dfs(1);
long long ans = 0;
while (q[1].size()) ans += q[1].top(), q[1].pop();
cout << ans << endl;
return 0;
}
\({\color{red}{[[省选联考 2020 A/B 卷] 冰火战士]}}\)
想到了一些性质
不过没抽象出本质的东西。
如果两个函数一个单调增，一个单调减，如果两个函数相交是理论最大值。
但是由于两个函数是离散的，可以考虑这样一个东西。
那么答案是如下两个\(k\)的最大值：
\(f_1(max(k)),f_1(k) < f_2(k)\)
\(f_1(min(k)),f_1(k) >= f_2(k)\)
由于函数性质，所以可以进行二分。
如果用树状数组二分的话，有两个\(log\)直接被卡到\(60\)
考虑树状数组倍增，对于这样一个性质树状数组\([d + 2 ^ i]\)计算的正是\([d + 1,d + 2 ^ i]\)\(d是2的整数次幂\)
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
const int N = 2e6 + 10;
int Q, n;
int h[N], tot, suf[N];
struct atom {
int id, x, y;
} star[N];
struct BIT {
int C[N];
int lowbit(int x) {
return x & -x;
}
void add(int x, int v) {
for (; x <= tot; x += lowbit(x))
C[x] += v;
}
int ask(int x) {
int ret = 0;
for (; x; x -= lowbit(x))
ret += C[x];
return ret;
}
} ice, fire;
int calc(int t) {
if (t < 1 || t > tot)
return -1;
return min(ice.ask(t), fire.ask(tot) - fire.ask(t - 1));
}
int main() {
cin >> Q;
int op, k, x, y;
rep(i, 1, Q) {
scanf("%d%d", &op, &k);
if (op == 1) {
scanf("%d%d", &x, &y);
} else {
x = star[k].x, y = -star[k].y, k = star[k].id;
}
star[i] = (atom) {
k, x, y
};
h[i] = x;
}
sort(h + 1, h + Q + 1);
tot = unique(h + 1, h + Q + 1) - h - 1;
rep(q, 1, Q) {
int x = lower_bound(h + 1, h + tot + 1, star[q].x) - h, y = star[q].y, k = star[q].id;
if (!k)
ice.add(x, y);
else
fire.add(x, y), suf[x] += y;
int p = 0, all = fire.ask(tot), sum = 0;
for (int i = 21; i >= 0; i--) {
int u = (p | (1 << i));
if (u <= tot && sum + ice.C[u] + fire.C[u] <= all + suf[u])
p = u, sum += ice.C[u] + fire.C[u];
}
int w1 = calc(p), w2 = calc(p + 1);
if (w1 <= 0 && w2 <= 0)
puts("Peace");
else if (w1 > w2)
printf("%d %d\n", h[p], w1 * 2);
else {
p = 0, sum = 0;
for (int i = 21; i >= 0; i--) {
int u = (p | (1 << i));
if (u <= tot && all - sum - fire.C[u] + suf[u] >= w2)
p = u, sum += fire.C[u];
}
printf("%d %d\n", h[p], w2 * 2);
}
}
return 0;
}//这个常数也巨大无比。。
标签：板刷,ll,省选,int,2021,ans,include,color,define 来源： https://www.cnblogs.com/dixiao/p/14576792.html