2019牛客暑期多校训练营（第四场）

传送门

参考资料：

　　[1]:官方题解（提取码：5kim）

　　[2]:标程（提取码：76lh）

A.meeting（树的直径）

•题意

　　有一颗由 n 个节点组成的树；

　　树上标记了 k 个点；

　　求树上某个节点到这 k 个点的最远距离的最小值；

•题解

　　

•Code

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=1e5+50;

int n,k;
int num;
int head[maxn];
struct Edge
{
    int to;
    int next;
}G[maxn<<1];
void addEdge(int u,int v)
{
    G[num]={v,head[u]};
    head[u]=num++;
}
int x[maxn];
int dis[maxn];

void DFS(int u,int f,int d)
{
    dis[u]=d;
    for(int i=head[u];~i;i=G[i].next)
    {
        int v=G[i].to;

        if(v != f)
            DFS(v,u,d+1);
    }
}
int Solve()
{
    if(k <= 1)
        return 0;

    DFS(x[1],x[1],0);

    int cur=x[1];
    for(int i=1;i <= k;++i)
        if(dis[cur] < dis[x[i]])
            cur=x[i];

    DFS(cur,cur,0);

    int ans=0;
    for(int i=1;i <= k;++i)
        ans=max(ans,dis[x[i]]);

    return (ans+1)/2;
}
void Init()
{
    num=0;
    mem(head,-1);
}
int main()
{
    Init();
    scanf("%d%d",&n,&k);

    for(int i=1;i < n;++i)
    {
        int u,v;
        scanf("%d%d",&u,&v);

        addEdge(u,v);
        addEdge(v,u);
    }
    for(int i=1;i <= k;++i)
        scanf("%d",x+i);

    printf("%d
",Solve());

    return 0;
}

 B.xor（线性基求交+线段树区间查询）

•题意

　　给你 n 个集合，每个集合中都有不超过 32 个数；

　　m 次询问，每次询问区间 [L, R] 中的所有集合，是否都有一个异或和等于 x 的子集。

　　$n ≤le≤ 5e4 , m le 5e4$，所有数值域 [0,2³²)。

•题解

　　线段树维护区间所有基底的交集；

　　然后 O(log n) 解决询问；

　　所以说，这道题的难点在于如何快速求解不同基底的交集，可以参考一下我的这篇博客；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=5e4+50;
 
int n,m;
struct Seg
{
    int l,r;
    ll base[40];
    int mid(){return l+((r-l)>>1);}
    void Init()
    {
        mem(base,0);
    }
    void Insert(ll x)
    {
        for(int i=32;i >= 0;--i)
            if(x>>i&1)
            {
                if(!base[i])
                {
                    base[i]=x;
                    return ;
                }
                x ^= base[i];
            }
    }
    bool Find(ll x)
    {
        for(int i=32;i >= 0;--i)
            if(x>>i&1)
                x ^= base[i];
        return x == 0 ? true:false;
    }
}seg[maxn<<2];
 
void pushUp(int pos)///将ls(pos),rs(pos)的base的交集更新到pos的base上
{
    ll all[40];
    ll B[40];
    memcpy(all,seg[ls(pos)].base,sizeof(all));
    mem(B,0);
 
    for(int i=32;i >= 0;--i)
    {
        ll x=seg[rs(pos)].base[i];
        ll y=x;
 
        for(int j=32;j >= 0;--j)
            if(x>>j&1)
            {
                if(!all[j])
                {
                    all[j]=x;
                    B[j]=y;
                    break;
                }
                x ^= all[j];
                y ^= B[j];
            }
        if(!x)
            seg[pos].Insert(y);
    }
}
void build(int l,int r,int pos)
{
    seg[pos]={l,r};
    seg[pos].Init();
 
    if(l == r)
    {
        int siz;
        scanf("%d",&siz);
        for(int i=1;i <= siz;++i)
        {
            ll x;
            scanf("%lld",&x);
            seg[pos].Insert(x);
        }
        return ;
    }
 
    int mid=seg[pos].mid();
    build(l,mid,ls(pos));
    build(mid+1,r,rs(pos));
 
    pushUp(pos);
}
bool query(int pos,int l,int r,ll x)///查询[l,r]区间的所有集合的子集是否都可以异或出x
{
    if(seg[pos].l == l && seg[pos].r == r)
        return seg[pos].Find(x);
 
    int mid=seg[pos].mid();
    if(r <= mid)
        return query(ls(pos),l,r,x);
    else if(l > mid)
        return query(rs(pos),l,r,x);
    else
        return query(ls(pos),l,mid,x)&query(rs(pos),mid+1,r,x);
}
void Solve()
{
    build(1,n,1);
 
    while(m--)
    {
        int l,r;
        ll x;
        scanf("%d%d%lld",&l,&r,&x);
 
        if(query(1,l,r,x))
            puts("YES");
        else
            puts("NO");
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    Solve();
 
    return 0;
}

---

C.sequence（单调栈+线段树）

•题意

　　给你两个数组 a,b；

　　求 $max_{l}^{r} ig{ min(a_{l},...,a_{r}) cdot sum_{l}^{r}b_{i} ig}$ , 1 ≤ l ≤ r ≤ n;

•题解

　　这道题和之前做的一道题（2019南昌网络预选赛）很相似，几乎就是一样的题；

　　通过单调栈求出以 $a_{i}$ 为最小值的最大范围 [L,R]；

　　在 [L,R] 内：

　　①如果 a_i > 0，那么，就需要找 [L,R] 内包含 a_i 的 $sum_{max}$；

　　②反之，如果 a_i ≤ 0，那么，就需要找 [L,R] 内包含 a_i 的 $sum_{min}$；

　　如何快速求解 $sum_{max}$ 和 $sum_{min}$ 呢？

　　对于情况①而言，$sum_{max}$ = max{ sum_i,sum_i+1,...,sum_R}-min{ sum_L-1,.....,sum_i-1};

　　而对于情况②而言，正好与①相反，$sum_{min}$ = min{ sum_i,sum_i+1,...,sum_R}-max{ sum_L-1,.....,sum_i-1};

　　看着求解公式有没有种线段树区间查询的味道？

•Code

#include<bits/stdc++.h>
using namespace std;
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define mem(a,b) memset(a,b,sizeof(a))
#define ll long long
#define INFll 0x3f3f3f3f3f3f3f3f
const int maxn=3e6+50;

int n;
int a[maxn];
int b[maxn];
int l[maxn];
int r[maxn];
ll sum[maxn];
int sta[maxn];
struct Seg
{
    int l,r;
    ll Max;
    ll Min;
    int mid(){return l+((r-l)>>1);}
}seg[maxn<<2];
void pushUp(int pos)
{
    seg[pos].Max=max(seg[ls(pos)].Max,seg[rs(pos)].Max);
    seg[pos].Min=min(seg[ls(pos)].Min,seg[rs(pos)].Min);
}
void buildSeg(int l,int r,int pos)
{
    seg[pos].l=l;
    seg[pos].r=r;

    if(l == r)
    {
        seg[pos].Max=seg[pos].Min=sum[l];
        return ;
    }

    int mid=l+((r-l)>>1);
    buildSeg(l,mid,ls(pos));
    buildSeg(mid+1,r,rs(pos));

    pushUp(pos);
}
ll queryMax(int l,int r,int pos)
{
    if(seg[pos].l == l && seg[pos].r == r)
        return seg[pos].Max;

    int mid=seg[pos].mid();

    if(r <= mid)
        return queryMax(l,r,ls(pos));
    else if(l > mid)
        return queryMax(l,r,rs(pos));
    else
        return max(queryMax(l,mid,ls(pos)),queryMax(mid+1,r,rs(pos)));
}
ll queryMin(int l,int r,int pos)
{
    if(seg[pos].l == l && seg[pos].r == r)
        return seg[pos].Min;

    int mid=seg[pos].mid();

    if(r <= mid)
        return queryMin(l,r,ls(pos));
    else if(l > mid)
        return queryMin(l,r,rs(pos));
    else
        return min(queryMin(l,mid,ls(pos)),queryMin(mid+1,r,rs(pos)));
}
void Work()
{
    int k=0;
    for(int i=1;i <= n;++i)
    {
        while(k > 0 && a[sta[k]] >= a[i])
            k--;

        l[i]=k == 0 ? 1:sta[k]+1;
        sta[++k]=i;
    }

    k=0;
    for(int i=n;i >= 1;--i)
    {
        while(k > 0 && a[sta[k]] >= a[i])
            k--;

        r[i]=k == 0 ? n:sta[k]-1;
        sta[++k]=i;
    }
}

ll Solve()
{
    buildSeg(0,n,1);///线段树
    Work();///单调栈

    ll ans=-INFll;
    for(int i=1;i <= n;++i)
    {
        if(a[i] > 0)
        {
            ll x=queryMax(i,r[i],1);
            ll y=queryMin(l[i]-1,i-1,1);

            ans=max(ans,(x-y)*a[i]);
        }
        else
        {
            ll x=queryMin(i,r[i],1);
            ll y=queryMax(l[i]-1,i-1,1);

            ans=max(ans,(x-y)*a[i]);
        }
    }
    return ans;
}

int main()
{
    scanf("%d",&n);

    for(int i=1;i <= n;++i)
        scanf("%d",a+i);

    sum[0]=0;
    for(int i=1;i <= n;++i)
    {
        scanf("%d",b+i);
        sum[i]=sum[i-1]+b[i];
    }

    printf("%lld
",Solve());
    return 0;
}

•段子

　　比赛的时候，求解区间最值用的是 ST 表，MLE 有没有.......

　　然后询问出题人：

　　

　　用 ST 表提交的时候，那是一个惨呀；

　　

　　内存超限了好几次，然后，想试一下运气，万一数据里的 n 都是小于 1e6 的呢；

　　然后，就有了 AC 前的一个 WA；

　　然后，突然，脑洞大开，为啥不用线段树呢！！！！

---

D.triples（构造）

•题意

　　给你 a，求满足 x%3 == 0 , y%3 == 0 , x | y = a 的 x,y;

　　输出 x,y；

•题解

　　将 a 用二进制数表示为：

　　　　$a=2^{k_1}+2^{k_2}+...+2^{k_n}$;

　　

　　也就是说，如果 a%3 ≠ 0，那么 n ≥ 3；

　　那么，对于任意一位 $2^{k_i}$ 有：

　　　　$2^{k_i} mod 3=1 or 2$;

　　假设 $2^{k_i} mod 3=1$ 有：

　　　　$2^{f_1},2^{f_2},...,2^{f_x}$;

　　$2^{k_i} mod 3=2$ 有：

　　　　$2^{g_1},2^{g_2},...,2^{g_y}$;

　　①如果 a%3 == 0
　　　　直接输出 a；

　　②如果 a%3 == 1

　　　　1)x > 1

　　　　　　构造 $ans1=a-2^{f_1},ans2=a-2^{f_2}$;

　　　　2)x == 1

　　　　　　构造 $ans1=a-2^{f_1},ans2=a-2^{g_1}-2^{g_2}$;

　　　　3)x == 0

　　　　　　那么，y > 3，因为如果 y == 3 ，那么 a%3 == 0；

　　　　　　构造 $ans1=a-2^{g_1}-2^{g_2},ans2=a-2^{g_3}-2^{g_4}$;

　　　　　　或者构造 $ans1=a-2^{g_1}-2^{g_2},ans2=2^{g_1}+2^{g_2}+2^{g_3}$;

　　③如果 a%3 == 2

　　　　与 a%3 == 1 正好对称；

　　解释：为什么要做减法，而不做加法？

　　　　　如果做加法的话，会产生进位，那么，ans1 | ans2 后可能大于 a；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long

ll a;
vector<ll >v[3];

void Solve()
{
    if(a%3 == 0)
    {
        printf("1 %lld
",a);
        return ;
    }

    v[1].clear();
    v[2].clear();

    for(int i=0;i < 62;++i)
    {
        ll k=1ll*1<<i;
        if(a&k)
            v[k%3].push_back(k);
    }

    ll ans1,ans2;
    if(a%3 == 1)
    {
        if(v[1].size() > 1)
            ans1=a-v[1][0],ans2=a-v[1][1];
        else if(v[1].size())
            ans1=a-v[1][0],ans2=a-v[2][0]-v[2][1];
        else
            ans1=a-v[2][0]-v[2][1],ans2=a-v[2][2]-v[2][3];
    }
    else
    {
        if(v[2].size() > 1)
            ans1=a-v[2][0],ans2=a-v[2][1];
        else if(v[2].size())
            ans1=a-v[2][0],ans2=a-v[1][0]-v[1][1];
        else
            ans1=a-v[1][0]-v[1][1],ans2=a-v[1][2]-v[1][3];
    }
    printf("2 %lld %lld
",ans1,ans2);
}
int main()
{
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%lld",&a);
        Solve();
    }
    return 0;
}

---

K.number（思维）

•题意

　　给你一个 串s，s 由 '0'~'9' 的数字组成；

　　求能整除 300 的不同的子串的个数；

　　对于相同内容的子串，如果含有位置不同的字符，当作不同子串处理；

　　并且可以有前导0；

•题解

　　能被 3 整除的数的特征为：各个位上的加和可以被 3 整除；

　　由于本题要找的是可以被 300 整除的串的个数；

　　那么，满足条件的子串肯定以 ≥ 两个0 结尾；

　　那么，关注点就在找连续的 0，并且连续的 0 的个数  ≥ 2 的位置；

　　每次从当前的 0 向前遍历，找包含当前位置 0 的满足条件的子串的个数；

　　注意，串 0300 也是满足条件的；

　　定义 zero[ i ] 表示以 i 位置为结尾的连续的 0 的个数；

　　sum[ i ] 表示 [1,i] 中包含第 i 个 0 且不能全部为 0 的满足条件的子串的个数；

　　例如：12300032100 (下标从 1 开始)

　　zero[4]=1 , zero[5]=2 , zero[6]=3 , zero[10]=1 , zero[11]=2;

　　zero[other]=0;

　　sum[6]=2 , sum[11]=7;

　　sum[other]=0;

　　sum[6]包含的子串为：3000,123000（不包含0,00,000这种情况，这种情况单独处理）；

　　为什么 sum[11]=7 呢？

　　2100 , 32100 , 032100 , 0032100 , 00032100 , 300032100 , 12300032100;

　　你会发现，其实，你会发现在这种条件下，只有 2100,32100 需要遍历找到，其余的都可以通过前面的信息找到；

　　sum[11] = 2 + sum[6] + zero[6] = 7;

　　你发现啥了没？

　　可以重用之前求的数据；

　　但是不是符合所有情况？

　　答案是否定的；

　　例如：12300021100

　　此时 sum[11] = 1; (2300021100)

　　也就是说，只有当 cur (cur = s[7]+s[8]+s[9] = 3+2+1 = 6，第一个例子) 整除 3 时才能重用之前求得的数据；

　　 不然，如果 cur ( cur = s[7]+s[8]+s[9] = 2+1+1 = 4，第二个例子) 不整除 3，那么，就只有接着向前遍历了；

　　当然，最后不要忽略了只包含 0 得情况；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=1e5+50;

char s[maxn];
ll zero[maxn];
ll sum[maxn];

ll Solve()
{
    mem(zero,0);
    mem(sum,0);

    ll ans=0;

    int len=strlen(s+1);
    int index=1;

    while(index <= len)
    {
        for(;index <= len && s[index] != '0';index++);

        for(;index <= len && s[index] == '0';index++)
            zero[index]=zero[index-1]+1;

        ll n=zero[index-1];///以index-1结尾的连续的0的个数

        if(n > 1)
        {

            ll cur=0;
            ll cnt=0;

            int i=index-n-1;
            while(i >= 1)
            {
                if(zero[i] > 1 && cur%3 == 0)///只有当cur%3==0时才能重用数据
                {
                    cnt += sum[i]+zero[i];
                    break;
                }
                ///否则，向前遍历
                cur += s[i]-'0';
                if(cur%3 == 0)
                    cnt++;

                i--;
            }

            sum[index-1]=cnt;
            
            ans += sum[index-1]*(n-1);
        }
        ans += n*(1+n)/2;///n个连续的0有n*(n+1)/2种串整除300
    }
    return ans;
}

int main()
{
//    freopen("C:\Users\hyacinthLJP\Desktop\in&&out\contest","r",stdin);
    scanf("%s",s+1);

    printf("%lld
",Solve());//23
    return 0;
}

•分析

　　这种思路实现的代码，时间复杂度应该可以退化到 O(n²) 吧，为啥过了呢？

　　暴力+AC = 未出现卡这种方法的数据；

•另一种思路

　　定义 sum_i 为前 i 为的和 mod 3 的值；

　　区间 [L,R] 满足条件，当且仅当 s[R] = s[R-1] = 0，并且 sum_R-2 = sum_L-1；

　　这样的话，只需记录一下 R-2 之前有多少值为 sum_R-2 的即可；

　　也就是记录 0,1,2 的个数；

　　不要忘记计算全部为 0 的情况；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e5+50;

char s[maxn];

ll Solve()
{
    ll ans=0;
    int sum=0;
    int index=1;
    int cnt[3]={1,0,0};
    int len=strlen(s+1);

    while(index <= len)
    {
        for(;index <= len && s[index] != '0';index++)
        {
            sum += s[index]-'0';
            sum %= 3;
            cnt[sum]++;
        }
        ll zero=0;
        for(;index <= len && s[index] == '0';zero++,index++);
    
        ///cnt[sum]记录的是区间[1,index-1]的 0,1,2 的个数
        ///需要减掉 index-1 对应的 sum%3 的值
        if(zero > 1)///(zero-1)种情况，每种都有cnt[sum]-1个满足条件的子串
            ans += (cnt[sum]-1)*(zero-1);

        ans += zero*(zero+1)/2;///全为0的情况

        cnt[sum] += zero;
    }
    return ans;
}
int main()
{
    scanf("%s",s+1);
    s[0]='#';

    printf("%lld
",Solve());

    return 0;
}