CF76题解

CF76

CF76A

链接

CF76A题意

给出一个图（$n\le 2\times 10^2,m\le 5\times 10^4$），每条边有两个属性 $(g_i,s_i)$，给出常数 $G,S$，求一个生成树 $T$ 使得 $G\times \max (g_i)+S\times \max (s_i)$ 最小，求出这个值。

CF76A题解

一眼顶针，鉴定为乱搞题
首先先将所有边按照 $g_i$ 排序，然后从小到大枚举 $s_i$，每次只加入 $s_j>s_i$ 的边，然后跑 $kruskal$。
但是这样显然是 $O(m^2)$ 的，考虑优化。
注意到如果在一次 $kruskal$ 的时候，一条边没有用到，那么以后就永远用不到了，因为选这条边显然不会优于之前的某种选法。
而且 $n$ 又这么小，每次只需要维护 $n-1$ 条边就好了。
然后就可以对每个 $s_i$ 算出对应的答案啦。
于是就可以 $O(nm)$ 快乐地过啦！

CF776A优化

1. 注意到刚开始至少需要选 $n-1$条边，可以先二分一个答案，然后从这个位置开始枚举 $s_i$。
2. 维护边用的集合可以用 $multiset$。

CF76A代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
inline int read(){
    int x = 0, f = 1;char ch = getchar();
    while(ch < '0' || ch > '9'){if(ch == '-') f = -1;ch = getchar();}
    while(ch >= '0' && ch <= '9'){x = (x << 1) + (x << 3) + (ch ^ 48);ch = getchar();}
    return x * f;
}
const int maxn = 2e2 + 10, maxm = 5e4 + 10;
int n, m;
int G, S;
struct edge{
    int u, v, g, s, nexte;
    edge(int u = 0,int v = 0,int g = 0,int s = 0,int ne = 0):u(u),v(v),g(g),s(s),nexte(ne){}
    friend bool operator < (edge a,edge b){return a.s < b.s;}
}e[maxm],edg;
int gold[maxm];

int fa[maxn];
int getf(int x){return fa[x] == x ? x : fa[x] = getf(fa[x]);}
multiset<edge> E;
typedef multiset<edge>::iterator iter;
bool check(int mid){
    int cnt = 1;
    for(int i = 1;i <= n;i++){fa[i] = i;}
    for(iter it = E.begin();it != E.end();it++){
        edg = *it;int fu = getf(edg.u), fv = getf(edg.v);
        if(fu == fv || edg.g > mid)continue;
        fa[fu] = fv;cnt++;
    }
    return cnt >= n;
}

signed main(){
    int u, v, g, s, ans = 0x3f3f3f3f3f3f3f3f;
    n =  read(); m = read();G = read(); S = read();
    for(int i = 1;i <= m;i++){
        u = read(); v = read(); g = read(); s = read();
        gold[i] = g;
        e[i] = edge(u,v,g,s);E.insert(e[i]);
    }
    sort(gold + 1,gold + 1 + m);
    int l = 1, r = m, res = -1;
    while(l <= r){
        int mid = l + r >> 1;
        if(check(gold[mid])){r = mid - 1;res = mid;}
        else l = mid + 1;
    }
    if(res == -1){puts("-1");return 0;}
    for(int point = res;point <= m;point++){
        int cnt = 1, maxx = 0;
        for(int j = 1;j <= n;j++)fa[j] = j;
        for(iter it = E.begin();it != E.end();it++){
            edg = *it;int fu = getf(edg.u), fv = getf(edg.v);
            if(edg.g > gold[point])continue;
            if(fu == fv){iter tmp = it;tmp--;E.erase(it);it = tmp;}
            else{fa[fu] = fv;maxx = edg.s;cnt++;}
            if(cnt == n)break;
        }
        if(cnt == n)ans = min(ans,maxx * S + gold[point] * G);
    }
    printf("%lld\n",ans == 0x3f3f3f3f3f3f3f3f ? -1 : ans);
    return 0;
}

CF76B

链接

CF76B题意

在平面上给出两条直线 $y=Y_0$ 和 $y=Y_1$。在 $y=Y_0$ 上有 $n$ 只老鼠，第 $i$ 只老鼠横坐标为 $x_{1,i}$，在 $y=Y_1$ 上有 $m$ 个奶酪，第 $i$ 个奶酪横坐标为 $x_{2,i}$。已知一只老鼠的捕食策略如下：
$1.$ 如果离这只老鼠最近的奶酪有且只有一个，那么这只老鼠会往这个奶酪移动。
$2.$ 如果有多个奶酪离老鼠距离最近，那么这只老鼠会选择向使所有老鼠中挨饿个数最少的奶酪移动。
每只老鼠的移动速度都是一样的，当某些老鼠到达某个奶酪并且当前奶酪还没有被吃掉时，他们会吃掉奶酪并且不再挨饿。如果某个老鼠在到达奶酪时奶酪已经被吃掉了，那么它不会再进行移动，此时我们认为它处于挨饿状态。
请输出最终处于挨饿状态的老鼠个数。

CF76B题解

考虑贪心的找答案，枚举对于每只老鼠，如果只满足第 $1$ 中情况就没办法了，但是如果满足第 $2$ 种情况，那么尽可能的让这只老鼠向左找\

CF76B代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
inline int read(){
    int x = 0, f = 1;char ch = getchar();
    while(ch < '0' || ch > '9'){if(ch == '-') f = -1;ch = getchar();}
    while(ch >= '0' && ch <= '9'){x = (x << 1) + (x << 3) + (ch ^ 48);ch = getchar();}
    return x * f;
}
const int maxn = 1e5 + 10,INF = 0x3f3f3f3f3f3f3f3f;
int n, m;
int x[maxn], y[maxn];
int minn[maxn];
signed main(){
    n = read(); m = read();read();read();
    for(int i = 1;i <= n;i++)x[i] = read();
    for(int i = 1;i <= m;i++)y[i] = read();
    int ans = 0;
    y[0] = -INF, y[m + 1] = INF;m++;sort(y,y + m + 1);
    memset(minn,0x3f,sizeof(minn));
    for(int i = 1;i <= n;i++){
        int j = lower_bound(y,y + m + 1,x[i]) - y;j--;
        // printf("j=%lld\n",j);
        int dis = min(x[i] - y[j],y[j + 1] - x[i]);
        if(y[j + 1] - x[i] > dis || (x[i] - y[j] == dis && (minn[j] == INF || minn[j] == dis))){j--;}
        if(minn[j + 1] == INF || minn[j + 1] == dis)ans++;
        minn[j + 1] = min(minn[j + 1],dis);
        // printf("i=%lld : %lld\n",i,ans);
    }
    printf("%lld\n",n - ans);
    return 0;
}

CF76C

链接

CF76C题意

给出一个字符串 $S$ （字符种类少于 $22$ 种）和一个代价上限 $t$
同时给出一个数组 $a_i$ 表示删除第 $i$ 种字符的花费，一个矩阵 $cos{t}_{i,j}$ 表示删除字符后的字符串 $T$ 中每对相邻的字母需要花费 $cos{t}_{T_i,T_{i+1}}$
求出最终花费小于代价上限的方案

CF76C题解

首先思考下暴力怎么写。
每次暴力枚举删除的字符集合，然后再扫一遍相邻的花费。
时间复杂度 $O(2^{k}n)$ 显然过不了。\

发现复杂度瓶颈在于计算相邻花费，思考如何优化。
不难发现，如果想让一对点对 $(i,j)$ 相邻，必须删除所有两者之间的字符，并且这两者之间不能有和这两个相同的字符
然后就非常的状压
设 $f_S$ 表示删除的字符集合是 $S$ 时的花费
首先让 $f_i={\sum }_{j\in i}{a}_j$
记录 $st{a}_j$ 表示到前面的字符 $j$ 之间需要删除哪些字符（初始为$-1$）
然后枚举 $S$ 中的每一位 $i$\

1. 如果 $st{a}_j\ne -1$
   1. 如果$S_i\notin st{a}_j$ 且 $j\notin st{a}_j$
      则$f_{st{a}_j}+=cos{t}_{j,S_i}$
      但是这样统计的话会让删除了 $j$ 或 $S_i$ 的情况也加了这种贡献，故
      $f_{st{a}_j|(1<<S_i)}-=cos{t}_{j,S_i}$
      $f_{st{a}_j|(1<<j)}-=cos{t}_{j,S_i}$
      但是同时删除了 $j,S_i$ 的情况减了两次这个贡献，故
      $f_{st{a}_j|(1<<j)|(1<<S_i)}+=cos{t}_{j,S_i}$
   2. 让 $st{a}_j|=(1<<S_i)$\

这一位枚举完了之后记得把$st{a}_{S_i}=0$
那么最终统计答案的时候先让 $f_i=f_i+{\sum }_{j\in i}{f}_{ixorj}$
然后枚举每一种删除方式集合 $sta$，如果 $f_{sta}\le t$ 且 $sta$ 是所有字符构成的集合的真子集，那么 $ans++$

CF76C细节

这道题虽说了只含有前 $k$ 个字符，可没说这 $k$ 个字符都有吃我四发提交

CF76C代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 2e5 + 10,maxk = 25;
int f[1 << maxk - 2], n, K, T;
char ch[maxn];
int a[maxn];
int cost[maxk][maxk];
int t[maxk], sta[maxk];
signed main(){
    scanf("%lld%lld%lld",&n,&K,&T);
    int all = 0;
    scanf("%s",ch + 1);for(int i = 1;i <= n;i++){a[i] = ch[i] - 'A';all |= (1 << a[i]);}
    for(int i = 1;i <= K;i++){scanf("%lld",&t[i]);f[1 << (i - 1)] += t[i];}
    for(int i = 1;i <= K;i++)
        for(int j = 1;j <= K;j++)
            scanf("%lld",&cost[i - 1][j - 1]);
    memset(sta,-1,sizeof(sta));
    for(int i = 1;i <= n;i++){
        for(int j = 0;j < K;j++)
            if(sta[j] >= 0){
                if(!((sta[j] >> a[i]) & 1) && !((sta[j] >> j) & 1)){
                    f[sta[j]] += cost[j][a[i]];
                    f[sta[j] | (1 << j)] -= cost[j][a[i]];
                    f[sta[j] | (1 << a[i])] -= cost[j][a[i]];
                    f[sta[j] | (1 << j) | (1 << a[i])] += cost[j][a[i]];
                }
                sta[j] |= (1 << a[i]);
            }
        sta[a[i]] = 0;
    }
    int ans = 0;
    for(int i = 0;i < K;i++)
        for(int j = 0;j < 1 << K;j++)
            if((j >> i) & 1)f[j] += f[j ^ (1 << i)];
    for(int i = 0;i < 1 << K;i++)
        if(f[i] <= T && i != all && (i & all) == i){ans++;}
    printf("%lld\n",ans);
    return 0;
}

CF76D

链接

CF76D题意

给你两个数 $A,B$，求一对满足 $X\oplus Y=B,X+Y=A$，且令 $X$ 尽可能小，无解输出 $-1$

CF76D题解

这啥啊
可知 $A-B$ 其实就是 $AandB$ 再向左移一位的结果，让 $X\leftarrow \frac{A-B}{2}$ 显然最优
然后特判下 $A<B$ 或者 $2\nmid (A-B)$ 的时候无解就没了

CF76D代码

#include<bits/stdc++.h>
#define ull unsigned long long
using namespace std;
signed main(){
    ull a, b;
    cin >> a >> b;
    if(a < b || (a - b) % 2 != 0)cout << -1 << endl;
    else cout << (a - b) / 2 << " " << a - (a - b) / 2 << endl;
    return 0;
}

CF76E

链接

CF76E题意

给 $n(n\le 10^5)$ 个点 $(x_i,y_i)$，求两两点距离的平方和

CF76E题解

先看横坐标
手推一下柿子：
${\sum }_{i=1}^n{\sum }_{j=i+1}^n(x_i-x_j{)}^2={\sum }_{i=1}^n{\sum }_{j=1}^n{x}_i^2+x_j^2-2\times x_i\times x_j=(n-1)\times {\sum }_{i=1}^n{x}_i^2-{\sum }_{i=1}^n{x}_i\times [({\sum }_{j=1}^n{x}_j)-x_i]$
纵坐标同理
然后就没了

CF76E代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
inline int read(){
    int x = 0, f = 1;char ch = getchar();
    while(ch < '0' || ch > '9'){if(ch == '-') f = -1;ch = getchar();}
    while(ch >= '0' && ch <= '9'){x = (x << 1) + (x << 3) + (ch ^ 48);ch = getchar();}
    return x * f;
}
const int maxn = 1e5 + 10;
int n;
int x[maxn], y[maxn];
int sumx, summx, sumy,summy;
signed main(){
    n = read();
    for(int i = 1;i <= n;i++){
        x[i] = read();y[i] = read();
        sumx += x[i];summx += (x[i] * x[i]);
        sumy += y[i];summy += (y[i] * y[i]);
    }
    int ans = 0;
    for(int i = 1;i <= n;i++){
        ans -= x[i] * (sumx - x[i]);
        ans -= y[i] * (sumy - y[i]);
    }
    ans += (n - 1) * (summx + summy);
    printf("%lld\n",ans);
    return 0;
}

CF76F

链接

CF76F题意

在一个数轴上有 $n$ 个事件，每个事件的坐标是 $x_i$，会在 $t_i$ 这一时刻出现（之后消失），请问

• 如果从原点在 $0$ 时刻出发，那么最多能看到多少个事件
• 如果可以从任意位置出发，那么最多能看到多少个事件

CF76F题解

首先对于一对点 $(i,j)(t_i>t_j)$，如果从 $j$ 在 $t_j$ 时刻出发，能看到 $i$ 的事件的条件

• 当 $x_i>x_j$ 时
  从 $j$ 能赶到 $i$ $⟺$ $-x_j+v\times t_j\le -x_i+v\times t_i$
• 当 $x_i<x_j$ 时
  从 $j$ 能赶到 $i$ $⟺$ $x_j+v\times t_j\le x_i+v\times t_i$

发现一个问题，就是将上面两个柿子推导一下

• 当 $x_i>x_j$ 时
  从 $j$ 能赶到 $i$ $⟺$ $-x_j+v\times t_j\le -x_i+v\times t_i$ $⟺$ $2x_j-x_j+v\times t_j\le 2x_i-x_i+v\times t_i$ $⟺$ $x_j+v\times t_j\le x_i+v\times t_i$
• 当 $x_i<x_j$ 时
  从 $j$ 能赶到 $i$ $⟺$ $x_j+v\times t_j\le x_i+v\times t_i$ $⟺$ $x_j-2x_j+v\times t_j\le x_i-2x_i+v\times t_i$ $⟺$ $-x_j+v\times t_j\le -x_i+v\times t_i$

也就是如果让 $j\leftarrow i$ 需要让上面两个柿子都成立
不妨设 $a_i=-x_i+v\times t_i,b_i=x_i+v\times t_i$
如果按照 $a_i$ 排序的话，就变成了要找一个最长的子序列使得 $b_i$ 单调不降
问题就变成了$LIS$
特别的，对于强制从原点出发的，因为 $a_0=b_0=0$，故所有 $a_i<0$ 或 $b_i<0$ 的点不能选，特判一下即可

CF76F代码

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    int x = 0, f = 1;char ch = getchar();
    while(ch < '0' || ch > '9'){if(ch == '-') f= -1;ch = getchar();}
    while(ch >= '0' && ch <= '9'){x=  (x << 1) + (x << 3) + (ch ^ 48);ch = getchar();}
    return x * f;
}
const int maxn = 1e5 + 10;
int n, V;
struct node{
    int pos, times;
    node(int times = 0,int pos = 0):pos(pos),times(times){}
    friend bool operator < (node a,node b){return a.times != b.times ? a.times < b.times : a.pos < b.pos;}
}a[maxn];

struct node1{
    int x, y;
    node1(int x = 0,int y = 0):x(x),y(y){}
    friend bool operator < (node1 a,node1 b){return a.x != b.x ? a.x < b.x : a.y < b.y;}
}b[maxn],tmp[maxn];

int x[maxn], y[maxn];
int que[maxn], r;

signed main(){
    n = read();
    for(int i = 1;i <= n;i++)a[i] = node(read(),read());
    V = read();
    int cnt = 0;
    for(int i = 1;i <= n;i++){
        b[i] = node1(-a[i].pos + V * a[i].times,a[i].pos + V * a[i].times);
        x[i] = -a[i].pos + V * a[i].times; y[i] = a[i].pos + V * a[i].times;
        if(b[i].x > 0 && b[i].y > 0){tmp[++cnt] = b[i];}
    }
    sort(x + 1,x + 1 + n);sort(y + 1,y + 1 + n);

    for(int i = 1;i <= cnt;i++){tmp[i] = node1(lower_bound(x + 1,x + 1 + n,tmp[i].x) - x,lower_bound(y + 1,y + 1 + n,tmp[i].y) - y);}
    sort(tmp + 1,tmp + 1 + cnt);
    int ans1 = 0;r = 0;
    que[0] = -1;que[++r] = 0x3f3f3f3f;
    for(int i = 1;i <= cnt;i++){
        int pos = upper_bound(que,que + r + 1,tmp[i].y) - que;
        if(que[pos] > tmp[i].y)que[pos] = tmp[i].y;
        if(pos >= r){que[++r] = 0x3f3f3f3f;}
    }
    ans1 = r - 1;

    for(int i = 1;i <= n;i++){b[i] = node1(lower_bound(x + 1,x + 1 + n,b[i].x) - x,lower_bound(y + 1,y + 1 + n,b[i].y) - y);}
    sort(b + 1,b + 1 + n);
    int ans = 0;r = 0;
    memset(que,0,sizeof(que));
    que[0] = -1;que[++r] = 0x3f3f3f3f;
    for(int i = 1;i <= n;i++){
        int pos = upper_bound(que,que + r + 1,b[i].y) - que;
        if(que[pos] > b[i].y)que[pos] = b[i].y;
        if(pos >= r){que[++r] = 0x3f3f3f3f;}
    }
    ans = r - 1;
    // for(int i = 1;i <= n;i++)printf("%d %d\n",b[i].x,b[i].y);
    printf("%d %d\n",ans1,ans);
    return 0;
}