2018.8.6 Noip2018模拟测试赛（十九）

日期：	八月六号	总分：	300分
难度：	提高 ~ 省选	得分：	10分（MMP）

题目目录：

　　T1：Tree

　　T2：异或运算

　　T3：Tree Restoring

赛后反思：

Emmmmmmm……

一直在打第一题…… 结果考完才发现dp少了一种情况……

除此之外，我无话可说…… Emmmmmm……

题解：

T1：Tree

树形背包dp，设$f[i][j][k(0/1/2)]$为$i$的子树中，选$j$条边，0：从$i$出发，到$i$结束/1：从$i$出发，到$i$的某个后代结束/2：后代开始，经过$i$，后代结束：

状态转移：

f[x][j+k+1][0]=min(f[x][j+k+1][0],f[x][j][0]+f[y][k][0]+2*e[i].dis);
f[x][j+k+1][1]=min(f[x][j+k+1][1],f[x][j][0]+f[y][k][1]+e[i].dis);
f[x][j+k+1][1]=min(f[x][j+k+1][1],f[x][j][1]+f[y][k][0]+2*e[i].dis);
f[x][j+k+1][2]=min(f[x][j+k+1][2],f[x][j][1]+f[y][k][1]+e[i].dis);
f[x][j+k+1][2]=min(f[x][j+k+1][2],f[x][j][0]+f[y][k][2]+2*e[i].dis);
f[x][j+k+1][2]=min(f[x][j+k+1][2],f[x][j][2]+f[y][k][0]+2*e[i].dis);

这样就能树形dp，时间复杂度 $O(n^2)$

COMPLETE CODE：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int n,k,x,y,z,tot=0,h[3005],siz[3005];
long long f[3005][3005][3],ans=1e18;
struct Edge{
    int x,y,dis,next;
}e[6005];
bool vis[3005];

inline void add_edge(int x,int y,int z){
    e[++tot].x=y,e[tot].dis=z;
    e[tot].next=h[x],h[x]=tot;
}

void dfs(int x,int fa){
    siz[x]=1;
    f[x][0][0]=0;    
    f[x][0][1]=0;
    for(int i=h[x];i;i=e[i].next){
        if(e[i].x==fa)continue;
        dfs(e[i].x,x);
        int y=e[i].x;
        for(int j=siz[x]-1;j>=0;j--)
        for(int k=siz[y]-1;k>=0;k--){
            f[x][j+k+1][0]=min(f[x][j+k+1][0],f[x][j][0]+f[y][k][0]+2*e[i].dis);
            f[x][j+k+1][1]=min(f[x][j+k+1][1],f[x][j][0]+f[y][k][1]+e[i].dis);
            f[x][j+k+1][1]=min(f[x][j+k+1][1],f[x][j][1]+f[y][k][0]+2*e[i].dis);
            f[x][j+k+1][2]=min(f[x][j+k+1][2],f[x][j][1]+f[y][k][1]+e[i].dis);
            f[x][j+k+1][2]=min(f[x][j+k+1][2],f[x][j][0]+f[y][k][2]+2*e[i].dis);
            f[x][j+k+1][2]=min(f[x][j+k+1][2],f[x][j][2]+f[y][k][0]+2*e[i].dis);
        }
        siz[x]+=siz[e[i].x];
    }
}

int main(){
    memset(f,0x7f,sizeof(f));
    scanf("%d%d",&n,&k);
    for(int i=1;i<n;i++){
        scanf("%d%d%d",&x,&y,&z);
        add_edge(x,y,z);
        add_edge(y,x,z);
    }
    dfs(1,-1);
    for(int i=1;i<=n;i++)
        ans=min(ans,min(f[i][k-1][1],f[i][k-1][2]));
    printf("%lld",ans);
}

T2：异或运算

可持久化Trie树，我之前还不知道可持久化，现在才知道，这跟主席树是一样的，是通过差分，维护区间。

我们按位贪心，由于$n$很小，对于每一位枚举$a$序列，统计现在的位置往优了走会有多少个值，如果大于$k$，可以走，如果小于$k$，所有反着走。

问题就这么迎刃而解了。（貌似这题用动态开点的主席树维护值域也能做……）

CODE：

#include<iostream>
#include<cstdio>
using namespace std;

int n,m,q,x,y,l,r,k,cnt=0,tot=0;
int a[1005],b[300005],root[300005];
struct Trie{
    int siz,next[2];
}v[20000005];
struct Node{
    int l,r,val;
}s[300005];

void insert(int &o,int last,int x){
    o=++tot;
    int p=o,q=last;
    for(int i=31;i>=0;i--){
        v[p]=v[q],v[p].siz++;
        v[p].next[(x>>i)&1]=++tot;
        p=v[p].next[(x>>i)&1];
        q=v[q].next[(x>>i)&1];
    }
    v[p].siz++;
}

int find(int cnt,int k){
    int ans=0;
    for(int i=31;i>=0;i--){
        int sum=0;
        for(int j=1;j<=cnt;j++){
            bool c=(s[j].val>>i)&1;
            sum+=v[v[s[j].r].next[c^1]].siz
                -v[v[s[j].l].next[c^1]].siz;
        }
        if(sum>=k){
            ans=ans<<1|1;
            for(int j=1;j<=cnt;j++){
                bool c=(s[j].val>>i)&1;
                s[j].r=v[s[j].r].next[c^1];
                s[j].l=v[s[j].l].next[c^1];
            }
        }else{
            k-=sum,ans=ans<<1;
            for(int j=1;j<=cnt;j++){
                bool c=(s[j].val>>i)&1;
                s[j].r=v[s[j].r].next[c];
                s[j].l=v[s[j].l].next[c];
            }
        }
    }
    return ans;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",a+i);
    for(int i=1;i<=m;i++)scanf("%d",b+i);
    for(int i=1;i<=m;i++)
        insert(root[i],root[i-1],b[i]);
    scanf("%d",&q);
    for(int i=1;i<=q;i++){
        scanf("%d%d%d%d%d",&x,&y,&l,&r,&k);
        cnt=0;
        for(int j=x;j<=y;j++)
            s[++cnt]=(Node){root[l-1],root[r],a[j]};
        printf("%d
",find(cnt,k));
    }
}

T3：Tree Restoring

很容易发现离所有点最远的点定是树的直径的两个端点。（我怎么就没想到呢？）

所有点的距离只能在$leftlceil{dover 2} ight ceil$到$d$之间，同时直径上的点两两对称，判断这些即可。

CODE：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

int n,x,a,b,t[105];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        t[x]++,a=max(a,x);
    }
    b=a+1>>1;
    for(int i=b+1;i<=a;i++)
        if(t[i]<2){
            printf("Impossible");
            return 0;
        }
    if(a&1){
        if(t[b]<2){
            printf("Impossible");
            return 0;
        }t[b]-=2;
    }else{
        if(t[b]<1){
            printf("Impossible");
            return 0;
        }t[b]-=1;
    }
    for(int i=1;i<=b;i++)
        if(t[i]){
            printf("Impossible");
            return 0;
        }
    printf("Possible");
}