10月清北学堂培训 Day 3

今天是钟皓曦老师的讲授~

zhx：题很简单，就是恶心一些qwq~

T1

别人只删去一个字符都能AC，我双哈希+并查集只有40？我太菜了啊qwq

考虑到越短的字符串越难压缩，越长的字符串越好压缩，所以我们可以先压缩短的字符串，再压缩长的字符串，这就是全损压缩法：

全损压缩法：

1.先把所有的字符串读进来，然后按照长度从小到大排序；

2.为了压缩不成问题，我们应该从最短的字符串开始压缩；

3.依次从 a , b , c …… , x , y , z , aa , ab ……这样的顺序进行压缩，如果两个字符串相同就把它们压缩成相同的，可以发现这样的压缩方法一定是最优的；

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<map>
#include<string>
#include<iostream>
#include<algorithm>

using namespace std;

const int maxn=1010;

map<string,string> ma;

string z[maxn];

int n,l=1,res[233],y[maxn];

bool cmp(int a,int b)
{
    return z[a]<z[b];
}

int main()
{
    cin >> n;
    for (int a=1;a<=n;a++)
    {
        cin>>z[a];
        y[a]=a;
    }
    res[1]=1;
    sort(y+1,y+n+1,cmp);
    for (int a=1;a<=n;a++)
    {
        string now = z[y[a]];
        if (ma.count(now)!=0) ;
        else
        {
            string cur = "";
            for (int a=l;a>=1;a--)
                cur = cur + (char)(res[a]+'a'-1);
            ma[now] = cur;
            res[1]++;
            for (int a=1;a<=l;a++)
                if (res[a]>26)
                {
                    res[a]=1;
                    res[a+1]++;
                }
            if (res[l+1]) l++;
        }
    }
    for (int a=1;a<=n;a++)
        cout << ma[z[a]] << endl;

    return 0;
}

T2

题意：

给了一棵有向树（外向树：所有边都是从根向外指的树就是外向树），并且在树上随便插了一条边，我们需要把这条边找出来，并保证这条边的编号尽可能的大 。

分两组情况：

1. 知道根节点是谁：

也就是能找到一个入度为 0 的点；

也就说明违和的边是从根下连到根下的，分为两种边：返祖边，横叉边；

但这两种边还是能归结到一种情况：有一个点的入度一定为 2；

我们就删掉连着这个入度为 2 的编号最大的边就好了；

2.不知道根节点是谁：

如果我们找不到一个入度为 0 的点的话，也就是说新加的那一条边的终点就是根节点；

那么会构成一个环，我们删掉环上编号最大的边删掉就好了；

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=100010;

int n,en,head,tail,in[maxn],ex[maxn][2],q[maxn],f[maxn],pre[maxn][2];

bool use[maxn];

struct edge
{
    int s,e,p;
    edge *next;
}*v[maxn],ed[maxn];

void add_edge(int s,int e,int p)
{
    en++;
    ed[en].next=v[s];v[s]=ed+en;v[s]->e=e;v[s]->p=p;
    in[e]++;
    ex[en][0]=s;ex[en][1]=e;
}

int get(int p)
{
    if (f[p]==p) return p;
    else return get(f[p]);
}

void init()
{
    en=0;
    memset(v,0,sizeof(v));
    memset(in,0,sizeof(in));
}

void read()
{
    scanf("%d",&n);
    for (int a=1;a<=n;a++)
    {
        int s,e;
        scanf("%d%d",&s,&e);
        add_edge(s,e,a);
    }
}

bool work1(int p,int d)
{
    memset(use,false,sizeof(use));
    use[p]=true;
    head=tail=1;
    q[1]=p;
    for (;head<=tail;)
    {
        int p=q[head++];
        for (edge *e=v[p];e;e=e->next)
            if (e->p!=d)
            {
                if (use[e->e]) return false;
                use[e->e]=true;
                pre[e->e][0]=p;
                pre[e->e][1]=e->p;
                q[++tail]=e->e;
            }
    }
    for (int a=1;a<=n;a++)
        if (!use[a]) return false;
    return true;
}

int work2(int p)
{
    memset(use,false,sizeof(use));
    use[p]=true;
    head=tail=1;
    q[1]=p;
    for (;head<=tail;)
    {
        int p=q[head++];
        for (edge *e=v[p];e;e=e->next)
        {
            if (use[e->e]) return e->p;
            use[e->e]=true;
            q[++tail]=e->e;
        }
    }
    return -1;
}

int work()
{
    for (int a=1;a<=n;a++)
        if (in[a]==2)
        {
            int p1=-1,p2=-1;
            for (int b=1;b<=n;b++)
                if (ex[b][1]==a)
                {
                    if (p1==-1) p1=b;
                    else p2=b;
                }
            if (p1>p2) swap(p1,p2);
            for (int b=1;b<=n;b++)
                if (in[b]==0)
                {
                    if (work1(b,p2)) return p2;
                    else return p1;
                }
        }
    for (int a=1;a<=n;a++)
        if (in[a]==0) return work2(a);
    for (int a=1;a<=n;a++)
        f[a]=a;
    for (int a=1;a<=n;a++)
    {
        int f1=get(ex[a][0]);
        int f2=get(ex[a][1]);
        if (f1==f2)
        {
            work1(ex[a][1],a);
            int p=ex[a][1],ans=a;
            while (p!=ex[a][1])
            {
                ans=max(ans,pre[p][1]);
                p=pre[p][0];
            }
            return ans;
        }
        f[f1]=f2;
    }
    return -1;
}

int main()
{
    init();
    read();
    int p=work();
    printf("%d
",p);

    return 0;
}

T3

想用 dp 骗 60% 的数据来着，却成了我这三个题的最高分？？

原谅我没看懂 zhx 老师的状态设置（他好像是直接设答案，不好想），我还是讲讲我的吧qwq：

状态设置：

dp [ i ][ j ]：当 Alice（下面称为 ' A '）杯内的茶剩下 i 吨， Bob（下面称为 ' B '）杯内的茶剩下 j 吨的概率是多少；

边界设置：

一开始的时候 A 和 B 都没有倒茶，所以 dp [ n ][ n ] = 1.0；

状态转移方程：

A 每次会等概率的倒出 k，2k，3k，4k 吨的茶，相应的 B 就会倒出 3k，2k，k，0 吨的茶，所以我们去枚举一下 A 倒出多少吨茶就好了：

dp [ i-x ][ j - ( 4k - x ) ] += dp [ i ][ j ] * 0.25；  （i 倒出之后还剩下 i-x，j 倒出之后还剩下 j - ( 4k - x )）

    for(int i=n;i>0;i--)
        for(int j=n;j>0;j--)
            for(int p=k;p<=4*k;p+=k)
                    dp[max(i-p,0)][max(j-4*k+p,0)]+=(double)dp[i][j]*0.25;   //注意如果杯里的茶不够p的话,剩下的是0而不是一个负数

答案：

这时候就要考验大家的语文水平了：

wrong answer = ( ans1 + ans2 ) / 2；

right answer = ans1 + ( ans2 / 2 )；

虽然我一开始觉得是第一种，但是通过分析样例发现原来是第二种，真是坏啊qwq

先想第一种 “ A 先把茶倒光的情况 ”：

我们设最后一次 A 倒了 x 吨的茶，那么 B 倒了 4k-x 吨的茶；

既然 A 一次就倒完了，并且 B 倒了之后还有剩余，那么也就是说倒之前 A 的杯子里的茶水是不超过 x 吨的，B 的杯子里的茶水是超过了 4k-x 吨的； 

那么我们把这些所有情况加起来就好了：

    for(int p=k;p<=4*k;p+=k)    //A先把茶倒完的情况:枚举A最后一次倒了多少多少 
        for(int i=1;i<=p;i++)
            for(int j=n;j>4*k-p;j--)  //枚举B最后一次倒之前倒了多少 
                ans1+=dp[i][j]*0.25;

然后想第二种 “ A 和 B 同时把茶倒光的情况 ”：

也就是说，最后一次倒茶时，A 的杯子内的茶水是不超过 x 吨的，同时 B 的杯子内的茶水是不超过 4k-x 吨的：

    for(int p=k;p<=4*k;p+=k)    //同时倒完的情况:枚举A最后一次倒了多少 
        for(int i=1;i<=p;i++)
            for(int j=1;j<=4*k-p;j++)
                ans2+=dp[i][j]*0.25;

然后输出 ans1 + ans2 / 2 就好了；

但是。。。这个题 n,k <= 1e9，你的算法是 O ( n² ) 的 ε=(´ο｀*))) 唉；

貌似 k 没用？

考虑到其实 n=10，k=2 和 n=5，k=1 是一种情况，它们的最后答案是一样的；

假如 n = 10， k = 5 和 n = 2 ， k = 1 是一样的！

那么我们就可以做一个转化：

n => n / k （上取整），k => 1；

那么现在的问题就变成：给你一个 n，问概率。

打表大法好啊！而且这个题就可以打表做qwq 。

两种方法打表：

1. 爆搜，而且可以加上记忆化；

状态设置：f [ i ][ j ] ：

f [ 0 ][ i ] = 1.0；

f [ i ][ 0 ] = 0.0；

f [ 0 ][ 0 ] = 0.5；

考虑怎么转移：

f [ i ][ j ] = 0.25 * ( f [ i-4 ][ j ] + f [ i-3 ][ j-1 ] + f [ i-2 ][ j-2 ] + f [ i-1 ][ j-3 ] )；

然后我们可以发现，当 n 超过了 235 的时候（n/k 后的新 n），答案就是 1 了 。

所以我们再加一个特判，就满分喽~

我的 lj 代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
int read()
{
    char ch=getchar();
    int a=0,x=1;
    while(ch<'0'||ch>'9')
    {
        if(ch=='-') x=-x;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
    {
        a=(a<<1)+(a<<3)+(ch-'0');
        ch=getchar();
    }
    return a*x;
}
int n,k;
double dp[4001][4001];
double ans1,ans2;
int main()
{
    //freopen("tea.in","r",stdin);
    //freopen("tea.out","w",stdout);    
    n=read();k=read();
    if(n%k!=0) n=n/k+1;
    else n=n/k;
    k=1;
    if(n>300)
    {
        printf("1.000000");
        return 0;
    }
    dp[n][n]=1.0;
    for(int i=n;i>0;i--)
        for(int j=n;j>0;j--)
            for(int p=k;p<=4*k;p+=k)
                {
                    //printf("dp[%d][%d]:%lf
",i,j,dp[i][j]);
                    dp[max(i-p,0)][max(j-4*k+p,0)]+=(double)dp[i][j]*0.25;
                    //printf("dp[%d][%d]:%lf
",max(i-p,0),max(j-4*k+p,0),dp[max(i-p,0)][max(j-4*k+p,0)]);
                }
    for(int p=k;p<=4*k;p+=k)    //A先把茶倒完的情况:枚举A最后一次倒了多少多少 
        for(int i=1;i<=p;i++)
            for(int j=n;j>4*k-p;j--)  //枚举B最后一次倒之前倒了多少 
                ans1+=dp[i][j]*0.25;
    for(int p=k;p<=4*k;p+=k)    //同时倒完的情况:枚举A最后一次倒了多少 
        for(int i=1;i<=p;i++)
            for(int j=1;j<=4*k-p;j++)
                ans2+=dp[i][j]*0.25;
    //printf("%lf %lf
",ans1,ans2);
    printf("%.6lf",ans1+ans2*0.5);
    return 0;
}

标程超短代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>

using namespace std;

const int maxn=201;

int n,k;

double f[maxn][maxn];

bool g[maxn][maxn];

double dfs(int n,int m)
{
    if (n<=0 && m<=0) return 0.5;
    if (n<=0) return 1.0;
    if (m<=0) return 0.0;
    if (g[n][m]) return f[n][m];
    g[n][m]=true;
    for (int a=1;a<=4;a++)
        f[n][m]+=0.25*dfs(n-a,m-4+a);
    return f[n][m];
}

double work(int n,int k)
{
    if (n/k>=maxn) return 1.0;
    return dfs((n/k)+(n%k?1:0),(n/k)+(n%k?1:0));
}

int main()
{
    scanf("%d%d",&n,&k);
    printf("%.6lf
",work(n,k));

    return 0;
}

图论题选讲 

Problem -1 是什么操作？ 

先假设没有障碍的情况：

因为在同一行或同一列的两个物体能互相看见，也就是说一个物体会用掉一行和一列；

如果我们从第 i 行连向了第 j 列，那么就说明 （i，j）这个位置可以放上物体；

我们放上一个障碍物，就可以看做把那一行和列分成了两个部分；

最后答案：我们最多能匹配多少对，就是我们最多能放多少个物体；

一遍匈牙利算法或网络流 Dinic 算法跑最大匹配就好了；

考虑到一开始的两个 1 既不能在同一行，也不能在同一列；

所以我们只需要判断是否有 n 个 1 都不在同一行或同一列上；

这就类似于上一个题啊qwq；

第 i 行连向第 j 列表示（i，j）这个位置的 1 可以选；

最后我们只需要看看最大匹配数是否是 n 就好了；

如果我们找不到的话，就说明无解！ 

2-SAT 问题：

有 n 个变量，每一个变量都是 bool 类型的，除了这 n 个变量以外，我们还有 m 个关系表达式，关系表达式差不多是这样的：

x₁ & x₂ = false（注意每个表达式只会有两个变量）

问给出 m 个关系表达式后，能否给这 n 个变量找出一个赋值的方法，使得满足所有的表达式； 

核心问题只需要考虑有没有解；

对于每个变量都只有两种取值：0 / 1，那么对于每个点，我们把每个变量看成 0点和 1点；

假如我们有一个关系：x₁ & x2 = false；

说明 x₁ 和 x₂ 中一定有一个为 false；

那么我们可以从 x₁ 的 true 连向 x₂ 的 false，从 x₂ 的 true 连向 x₁ 的 false；

要注意只有关系明确的时候才能建边；

解释一下：

如果 x₁ 的值为 true ，那么如果我们 x₂ 的值再为 true 的话，就不满足 “ x₁ & x₂ = false ” 这个式子了，所以如果 x₁ 为 true 的话是能明确推出 x₂ 为 false 的；

我们可以从 x₂ 的 flase 向 x₁ 的 true 连边吗？这样也能满足关系式；

显然不能，因为你如果 x₂ 为 false 的话，x₁ 为 true 或 false 是都可以的，这不是明确的关系，我们不能建边；

所以一般的建边方式为：

若 x_a = p 或 x_b = q 中至少有一个满足，那么我们建两条边：

x_a (¬p) -> x_b (q)

x_b (¬q) -> x_a (p) 

 

如果一个变量必须等于 true，那么我们从这个点的 false 连向这个点的 true； 

表示我们从 false 走也会走到 true，也就是说只能等于 true；

怎么判断是否有解？

假如说我们从一个点的 true 走到了它自己的 false，那么就说明这个点只能是 false；假如我们从一个点的 false 走到了它自己的 true，那么久说明这个点只能是 true；以上两种情况是有解的 。

无解的情况就是：某一个变量的 false 能走到 true，从 true 也能走到 false，也就是说，某一个变量的两个取值在同一个强连通分量内的话，就说明无解。

所有的 2-SAT 问题都是这么做；

更详细版及代码实现 

最大化最小值问题，二分喽~

二分爆炸半径的最小值 r，看 r 是否合法；

既然最小值是 r 了，我们不妨直接让所有的炸弹的爆炸范围都是 r；

我们看到每一组都有两种取值，自然对应得就是 2-SAT 了；

建图：

假如我们第一组的第一个炸弹能扎到第二组的第一个炸弹，那么就说明这两个炸弹不能同时选，所以我们从第一组的第一个炸弹向第二组的第二个炸弹连一条边；反之，我们从第一组的第二个炸弹向第二组的第一个炸弹连边；（注意连有向边）

每次 n² 暴力建边，然后 tarjan 判断是否合法就好了； 

合法就向更大的 r 去枚举，直至不合法 ，此时的 r 就是答案了。

给你一个 n * m 的棋盘，上面有些格子是黑色的，有些格子是白色的，还有一些障碍（不能放骨牌），现在你有一种类似于 ' L ' 型的骨牌，两端是白色的，中间是黑色的，要求将骨牌放在棋盘上，使得黑色部分放在黑色格子上，白色部分放在白色格子上，每个格子只能被覆盖一次（只能放一个骨牌），问能否能将整个棋盘覆盖满？

我们考虑将黑点拆点，使得一个黑格子对于一个白格子；

但是有一个问题：我们可能搞出来的不是 ' L ' 型；

所以我们将白格子分为上下白格子和左右白格子；

这样的话，一个黑格子对应一个上下白格子，一个黑格子对应一个左右白格子，合起来的话就能保证它是一个 ' L ' 型的了；

对于更大的数据，只能用 2-SAT 做了：

看到这道题只是判断有没有解，那么自然就想到了 2-SAT 。

我们可以为每个黑点造两个变量：左右变量和上下变量，每个变量有两种取值，这样就变成了 2-sat 问题 。

点建好了，边怎么建？

如果两个黑格子的曼哈顿距离不超过 2，它们之间就有可能会冲突：

假设我们有两个黑格子的分布是：左上和右下，那么它们的建边关系就是：

实际也就 6 种情况，我们分别根据它们的位置关系建边就可以了：

然后我们跑一遍 tarjan 判断其是否有解；

总时间复杂度 O ( nm )； 

我们依然可以用 2-SAT 做；

我们考虑每个提案到底是通过还是否决；

我们先考虑每个人投一票的情况：

假如一个人对了一号提案投了反对票，由于要有一半以上的提案和投票情况相符，所以这个提案一定否决，我们从一号提案的通过连向否决，表示一号提案一定被否决：

发现投两票和投一票的情况一样，也是需要所投的两个提案必须都和投票情况相符；

考虑投三票的情况：假设一个人投了三、四、五号提案的通过，假如三号提案被否决了，由于至少要有一半以上的提案符合投票情况，所以剩下的四、五号提案是一定被通过的，所以我们可以从三号提案的否决分别连向四、五号提案的通过；同理我们再从四号提案的否决连向三、五号提案的通过，从五号提案的否决连向三、四号提案的通过：

发现投四票的情况也是和投三票的情况一样，一个不满足剩下的三个都必须满足；

答案：

如果一个提案能从通过走到否决，那么说明这个提案一定会被否决；如果一个提案能从否决走到通过，那么说明这个提案一定会被通过；如果既能从通过走到否决，也能从否决走到通过，那么说明这个提案不一定被通过或者否决；

由于树是个二分图，所以我们可以从树的角度去考虑； 把一张图变成一棵树有两种方法：

1.生成树；

2.缩点；

一张图如果不是二分图，就说明有基环存在，所以我们要把所有的基环都干掉，所以我们所需要干掉的这条边就是所有基环的交集的那条边；

那么怎么求所有基环的交集？

我们先在这个图上随便求一棵生成树，然后我们求完生成树后，所有的边分成了两类：树边和非树边；

如果没有不在树上的边，就说明这个图是二分图了；如果有一条不在树上的边，连了两个颜色一样的点，形成了一个基环，我们需要破坏掉基环；

如果我们只能找到一条非树边，那就说明这一张图里面就一个基环，那么我们删掉这个基环上的任意一条边都可以使这个图变成二分图；

如果说存在两条及以上的基环，我们并不能通过删除一条非树边来搞掉所有基环，此时我们要删的就是一条树边；

如果一条非树边形成了一个基环，我们就将这个基环上的所有边的权值+1；这么瞎搞一通以后，如果我们发现有一条树边的权值等于基环的个数，也就是说这条树边被所有的基环包含在内，所以这一条边就是答案了；

至于+1的操作，我们可以使用树上差分或者树链剖分来实现；

看着 A 国人少条件少，先欺负分析 A 国：

化简一下 A 国交朋友的条件：

x₁ ^ x₂ %2 = 1；

保证两个友善值异或后是奇数，也就是说两个数表示成二进制后最右边的那一位不同，也就是说两个人的友善值一奇一偶；

那么最后的朋友圈中 A 国就只有 2 个人（超过了2人的话肯定有两个人的奇偶性相同，那么就不会是朋友了）；

所以现在的问题就是找 B 国最大的朋友圈；

给你一张图让你求最大团是 NPC 问题，那么这个图不是随便给你的，一定是含有某个神奇的性质的；

我们来分析 B 国交朋友的条件：

第一个条件：x₁ ^ x₂ % 2 = 0；

与 A 国的分析情况相似，也就是说友善值同奇偶的人可以互相交朋友；

第二个条件：x₁ | x₂ 在二进制表示上有奇数个1；

这个条件看起来有点奇怪，但可以确定的是这个条件使得在 B 国一奇一偶的人也可以交朋友，那么总体来说 B 国的情况就是这个亚子：

看这个亚子有点像二分图呐，但是我们知道二分图两侧的点之间是没有连边的呀，但是这个图却两两连了边（没画全，其实是不想画了，意思意思就好），然后我们发现这个图的补图是一个二分图！

二分图的补图： 

反图的最大独立集就是原图的最大团；

我们要在补图中找到一个最大的独立集，使得原图求出来的是最大团；

每有一个匹配，我们所能够选的点就少一个，所以最后的答案就是：n+m - 最大匹配；

每种颜色的格子最多两个？神奇的数字 2！

假设我们考虑每种颜色的格子只有 1 个的话，那么每种颜色的格子要去的方向是固定的；

那么我们肯定能通过 “ 行操作 + 列操作 + 行操作 ” 或 “ 列操作 + 行操作 + 列操作 ” 来完成；

那么最后的答案一定不超过：min（c_a+2c_b ，c_b + 2c_a）；

如果只有一个系列的操作，我们直接通过暴力去求；

如果需要通过两个系列去解决呢？ 

如果我们发现同一行的两个格子要到同一列去，或者同一列的两个格子要去同一行去，那么我们就不能省去第三步；

但是原题每种颜色都至少有 2 个呀？

我们可以 dfs 每个格子去哪里，但是这样的话时间复杂度为 O ( 2⁴⁵⁰⁰⁰ )；

假设一种颜色的两个初始位置 a，b ，在目标状态移动到了 A，B；

那么只有两种取值：

1. a -> A，b -> B；

2. a -> B，b -> A； 

如果 a 和 c 在同一行，A 和 C 在同一列，那么就说明我们不能通过两部操作来完成；

如果 a 去 A , b 去 B，那么 c 只能去 D，同样 d 去 c；

如果 a 去 B , b 去 A，那么 c 只能去 C，同样 d 去 D；