2019.09.07 多校联合训练（提高组）

最新推荐文章于 2023-03-16 09:00:00 发布

C202044zxy

最新推荐文章于 2023-03-16 09:00:00 发布

阅读量213

点赞数

分类专栏： noip模拟

本文链接：https://blog.csdn.net/C202044zxy/article/details/100837753

版权

noip模拟专栏收录该内容

12 篇文章 0 订阅

订阅专栏

感觉这几道题还是挺好的，写个套题博客八。

四个质数的和

一、题目

题意
给定了一个正整数 N。有多少种方法将 N 分解成为四个质数 a,b,c,d 的和。
数据范围
$T\leq 10,n\leq 100000$

二、解法

考试是无脑了一发记忆化搜索，结果T成70分。
PPL orz，直接想到正解。
我们考虑把四个质数拆成两个部分， $s [i]$ 表示由两个质数组成 $i$ 的方案数，根据乘法原理，答案为：
$\sum_{i=1}^{n} s[i]\times s[n-i]$
$s$ 怎么算呢，暴力枚举即可。（what??）
然后就愉快的卡过了。

#include <cstdio>
#define LL long long
const int MAXN = 100005;
int read()
{
    int num=0,flag=1;
    char c;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9')num=(num<<3)+(num<<1)+(c^48),c=getchar();
    return num*flag;
}
int T,n,cnt,p[MAXN],s[MAXN];
bool vis[MAXN];
void sieve(int n)
{
    for(int i=2; i<=n; i++)
    {
        if(!vis[i]) p[++cnt]=i;
        for(int j=1; j<=cnt && p[j]*i<=n; j++)
        {
            vis[i*p[j]]=1;
            if(p[j]%i==0) break;
        }
    }
}
int main()
{
    sieve(1e5);
    for(int i=1; i<=cnt; i++)
        for(int j=1; j<=cnt && p[i]+p[j]<=1e5; j++)
            s[p[i]+p[j]]++;
    T=read();
    while(T--)
    {
        n=read();
        LL ans=0;
        for(int i=1; i<n; i++)
            ans+=1ll*s[i]*s[n-i];
        printf("%lld\n",ans);
    }
}

匹配最大异或

一、题目

假设给定了两个整数 m,n。有 n 个互不相同的整数 x1,x2,…,xn（0≤xi≤2m-1）。对于每一个属于 0 到 2m-1 的 y，我们找到 py使得 xp_y异或 y 有最大值。即对于任意的 i≠py，有 y⊕xp_y >y⊕ xi。（其中⊕表示二进制异或）。

现在我们把这个问题反过来。给定 m 和 n，以及序列 p0,p1,…,p2^m-1，计算有多少个不同序列 x1,x2,…,xn可以通过上文描述的问题生成出序列 p。两个序列是不同的当且仅当存在一个 i 使得两个序列中 xi是不同的。

答案对 1000000007(109+7)取模。

二、解法

考虑最高的二进制位，按照最高的二进制位将所有数字分成两个集合（最高位为 0 的一组，最高位为 1 的一组）。若 x 数列中既有最高位为 0 的，也有最高位为 1 的，则两个集合对应的 p 一定没有交，则可以将第一位去掉之后分开来考虑（又变回原问题）。否则，两个集合的 p 一定一一对应，而最高位可以取任何值（0 或 1），将最高位去掉后则又变回原问题。

求解的过程类似分治/动态规划的过程。 F(l,r)表示考虑[l,r]这个集合可以得到的合法的方案数。
1、若 p[l,mid]和 p[mid+1,r]各不相同，则返回 F(l,mid) * F(mid+1, r)
2、若 p[l,mid]=p[mid+1,r]，则返回 2*F(l,mid)
3、若不是上述两种情况，返回 0

#include <cstdio>
#include <iostream>
using namespace std;
#define int long long
const int MAXN = 200005;
const int MOD = 1e9+7;
int read()
{
    int num=0,flag=1;
    char c;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9')num=(num<<3)+(num<<1)+(c^48),c=getchar();
    return num*flag;
}
int m,n,p[MAXN],tmp[MAXN];
int F(int l,int r)
{
    if(l==r) return 1;
    int mid=(l+r)>>1,mark=1,flag=1;
    for(int i=l;i<=mid;i++) if(p[i]^p[i+mid-l+1]) mark=0;
    if(mark) return 2*F(l,mid)%MOD;
    for(int i=l;i<=mid;i++) tmp[p[i]]=1;
    for(int i=mid+1;i<=r;i++) if(tmp[p[i]]) flag=0;
    for(int i=l;i<=mid;i++) tmp[p[i]]=0;
    if(flag) return F(l,mid)*F(mid+1,r)%MOD;
    return 0;
}
signed main()
{
    m=read();n=read();
    n=(1<<m);
    for(int i=0;i<n;i++)
        p[i]=read();
    printf("%lld\n",F(0,n-1));
}

染色相邻的边

一、题目

题意
给定一个 N 个点的树，点的标号从 1 到 N。
一条树上点 a 到点 b 的简单路径 P 是一个 k 个点的序列（a=P1,P2,…,Pk=b)，相邻的两个点之间有边连接且任何一个点至多在序列中出现一次。注意 a 可能和 b 是相等的。简单路径上的边就是连接序列上相邻两个点的边。
一条简单路径的邻边是只有一个端点在简单路径上的边。
树上的每条边是黑色的或者白色的。最开始所有的点都是黑色的。有 Q 次操作，有两种操作类型。
0.计算 a 到 b 的简单路径上有多少条边是黑色的。
1.将简单路径 a 到 b 上的边全部设置成白色的。将简单路径 a 到 b 上的邻边设置成黑色的。
数据范围
对于 5％的数据：N=1
对于 20％的数据：N≤200
对于 30％的数据：N≤2000
另外 20％的数据：树的形态是一条链
另外 30％的数据：操作 1 中 ai=bi，且 ai是随机生成的。
对于 100％的数据：1≤N≤200000，1≤Q≤300000

二、解法

考试时都看出来是树链剖分，就是不知道怎么维护。
我妄想通过乱搞骗分搞到70分，结果 $G G$ ，具体方法就是分情况讨论，（希望有人继承我的骗分大法）。
直接说正解把 $q w q$ 。
易知一条为黑色的充要条件时这条边的两个端点被不同时间覆盖（默认一开始每个点的时间不同）。
这样就给我们的树剖提供了机会，我们维护每个点的时间戳，对于1操作我们直接模板式修改点，对于2操作我们用点的信息去拼答案。
具体操作就是用结构体把查询的信息拼接在一起，有一些细节可以看代码，个人觉得应该不难理解。

#include <cstdio>
#include <iostream>
using namespace std;
#define LL long long
const int MAXN = 200005;
int read()
{
    int num=0,flag=1;
    char c;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9')num=(num<<3)+(num<<1)+(c^48),c=getchar();
    return num*flag;
}
int n,q,cnt,tot,Index,f[MAXN],fa[MAXN],siz[MAXN];
int dep[MAXN],top[MAXN],num[MAXN],son[MAXN];
struct edge
{
    int v,next;
} e[MAXN*2];
struct node
{
    int cl,cr,sum,lazy;
    node operator + (node x) const
    {
        if(cl==0) return x;
        if(x.cl==0) return node{cl,cr,sum,0};
        return node{cl,x.cr,sum+x.sum+(cr!=x.cl),0};
    }
} tr[MAXN*4];
void dfs1(int u,int par)
{
    fa[u]=par;
    dep[u]=dep[par]+1;
    siz[u]=1;
    for(int i=f[u]; i; i=e[i].next)
    {
        int v=e[i].v;
        if(v==par) continue;
        dfs1(v,u);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    num[u]=++Index;
    top[u]=tp;
    if(son[u]) dfs2(son[u],tp);
    for(int i=f[u]; i; i=e[i].next)
        if(e[i].v^fa[u] && e[i].v^son[u])
            dfs2(e[i].v,e[i].v);
}
void build(int i,int l,int r)
{
    if(l==r)
    {
        tr[i]=node{++cnt,cnt,0,0};
        return ;
    }
    int mid=(l+r)>>1;
    build(i<<1,l,mid);
    build(i<<1|1,mid+1,r);
    tr[i]=tr[i<<1]+tr[i<<1|1];
}
void down(int i)
{
    if(!tr[i].lazy) return ;
    int x=tr[i].lazy;
    tr[i<<1|1]=tr[i<<1]=node{x,x,0,x};
    tr[i].lazy=0;
}
void updata(int i,int l,int r,int L,int R,int c)
{
    if(L<=l && r<=R)
    {
        tr[i]=node{c,c,0,c};
        return ;
    }
    if(R<l || r<L) return ;
    down(i);
    int mid=(l+r)>>1;
    updata(i<<1,l,mid,L,R,c);
    updata(i<<1|1,mid+1,r,L,R,c);
    tr[i]=tr[i<<1]+tr[i<<1|1];
}
node query(int i,int l,int r,int L,int R)
{
    if(L<=l && r<=R)
        return tr[i];
    if(R<l || r<L)
        return node{};
    down(i);
    int mid=(l+r)>>1;
    return query(i<<1,l,mid,L,R)+query(i<<1|1,mid+1,r,L,R);
}
void modify(int u,int v)
{
    ++cnt;
    while(top[u]^top[v])
    {
        if(dep[top[u]]<=dep[top[v]]) swap(u,v);
        updata(1,1,n,num[top[u]],num[u],cnt);
        u=fa[top[u]];
    }
    if(dep[u]<=dep[v]) swap(u,v);
    updata(1,1,n,num[v],num[u],cnt);
}
int ask(int u,int v)
{
    node r1= {},r2= {},ans= {};
    while(top[u]^top[v])
    {
        if(dep[top[u]]>=dep[top[v]])
        {
            r1=query(1,1,n,num[top[u]],num[u])+r1;
            u=fa[top[u]];
        }
        else
        {
            r2=query(1,1,n,num[top[v]],num[v])+r2;
            v=fa[top[v]];
        }
    }
    if(dep[u]>=dep[v])
    {
        r2.cr=r2.cl;
        ans=(r2+query(1,1,n,num[v],num[u]))+r1;
    }
    else
    {
        r1.cr=r1.cl;
        ans=(r1+query(1,1,n,num[u],num[v]))+r2;
    }
    return ans.sum;
}
int main()
{
    n=read();
    for(int i=1; i<n; i++)
    {
        int u=read(),v=read();
        e[++tot]=edge{v,f[u]},f[u]=tot;
        e[++tot]=edge{u,f[v]},f[v]=tot;
    }
    dfs1(1,0);
    dfs2(1,1);
    build(1,1,n);
    q=read();
    for(int i=1; i<=q; i++)
    {
        int op=read(),u=read(),v=read();
        if(op==0)
        {
            printf("%d\n",ask(u,v));
        }
        else
        {
            modify(u,v);
        }
    }
}