牛客编程巅峰赛S1第3场 - 黄金&钻石(题解)

A-找卧底

题意：

问给定的$n+1$个数中，哪个数出现了两次。

思路：

签到，直接做。

Code:

class Solution {
public:
    /**
     * 
     * @param n int整型 
     * @param a int整型vector 
     * @return int整型
     */
    int search(int n, vector<int>& a) {
        // write code here
        int cnt[200005];
        int ans=0;
        for(int i=0;i<=n;++i){
            cnt[a[i]]++;
            if(cnt[a[i]]==2){
                ans=a[i];
            }
        }
        return ans;
    }
};

B-父子情深

题意：

在一颗有 $n$ 个结点且以 $1$ 为根节点树上，起初每个结点的初始权值为 $0$ 。

现在有 $q$ 次操作，每次操作选择将以 $r_i$​ 为根节点的子树上的所有结点权值增加 $x_i$​ 。

求 $q$ 次操作后从 $1$到 $n$ 每个结点的权值。

思路：

比较经典的树上问题。这里仅抛出解法，不对代码思路进行讲解。

• 解法1：$dfs$序$+$线段树区间修改、单点查询。
• 解法2：树剖。

$dfs$序$+$线段树是老套路了，如果不了解的话可以做一下类似题：
Hdu-3974

Code:

class Solution {
public:
    /**
     * 从 1 到 n 每个结点的权值。
     * @param n int整型 
     * @param Edge Point类vector (u, v) 集合
     * @param q int整型 
     * @param Query Point类vector Point.x 为题中 r, Point.y为题中 v
     * @return long长整型vector
     */
    long long tree[200005*4];
    long long lazy[200005*4];
    int d[200005];//È
    int n,l,r;
    std::vector<int> v[200005];
    #define mid ((l+r)>>1)
    #define lson l,mid,rt<<1
    #define rson mid+1,r,rt<<1|1
    int cnt=0;
    int dfs_xu[200005];
    int st[200005*4];
    int ed[200005*4];
    void dfs(int x,int fa){
        st[x]=++cnt;
        for(int i=0;i<(int)v[x].size();++i){
            int y=v[x][i];
            if(y==fa)continue;
            dfs(y,x);
        }
        ed[x]=++cnt;
    }
    void pushdown(int l,int r,int rt){
        tree[rt<<1]+=1ll*(mid-l+1)*lazy[rt];
        tree[rt<<1|1]+=1ll*(r-mid)*lazy[rt];
        lazy[rt<<1]+=lazy[rt];
        lazy[rt<<1|1]+=lazy[rt];
        lazy[rt]=0;
    }   
    void pushup(int rt){
        tree[rt]=tree[rt<<1]+tree[rt<<1|1];
    }
    void build(int l,int r,int rt){
        if(l==r){
            tree[l]=0;
            return;
        }
        build(lson);
        build(rson);
        pushup(rt);
    }
    void update(int L,int R,int l,int r,int rt,int val){
        if(L<=l&&r<=R){
            tree[rt]+=(r-l+1)*val*1ll;
            lazy[rt]+=val*1ll;
            return ;
        }
        if(lazy[rt]!=0)pushdown(l,r,rt);
        if(L<=mid){
            update(L,R,lson,val);
        }
        if(R>mid){
            update(L,R,rson,val);
        }
        pushup(rt);
    }
    long long query(int L,int R,int l,int r,int rt){
        if(L<=l&&r<=R){
            return tree[rt];
        }
        long long ans=0;
        if(lazy[rt]!=0)pushdown(l,r,rt);
        if(L<=mid){
            ans=query(L,R,lson);
        }
        if(R>mid){
            ans=query(L,R,rson);
        }
        return ans;
    }
    vector<long> solve(int n, vector<Point>& Edge, int q, vector<Point>& Query) {
        // write code here
        for(int i=0;i<n-1;++i){
            int l=Edge[i].x;
            int r=Edge[i].y;
            v[l].push_back(r);
            v[r].push_back(l);
        }
        dfs(1,1);
        build(1,cnt,1);
        
        for(int i=0;i<q;++i){
            int ri=Query[i].x;
            int vi=Query[i].y;
            update(st[ri],ed[ri],1,cnt,1,vi);
        }
        vector<long>ans;
        for(int i=1;i<=n;++i){
            //cout<
            ans.push_back(query(st[i],st[i],1,cnt,1));
        }
        return ans;
    }

};

C-旋转跳跃

题意：

牛牛有一个长为 $n$ 的排列 $p$ ，与 $m$ 对 $(x_i,y_i)$。

每对 $(x_i,y_i)$ 表示可以将 $p_{x_i}$​​ 的值与 $p_{y_i}$​​ 的值互换。

$m$ 对 $(x_i,y_i)$ 的使用顺序与次数不限。

牛牛想知道，任意次操作之后他能得到的字典序最小的排列是什么。

输入：
第一个参数为 $n$，$1\le n\le 100,000$

第二个参数为 $m$，$1\le m\le 100,000$

第三个参数为初始排列 $p$，$1\le p_i\le n$

第四个参数为 $m$ 对$(x_i,y_i)$， $1\le x_i,y_i\le n,x_i\ne y_i$

思路：

• $m$对关系到最后会造成若干个联通块，一个联通块内的数字可以互相交换。不同联通块之间的数字无法交换。并查集维护。
• 要求字典序最小，即贪心，将联通块内的数字排序(小到大)即可，排序整体复杂度还是在$O(nlogn)$。
• 输出的时候用$co{n}_i$数组标记以$i$为首的联通块目前输出了$co{n}_i$个。

Code:

/**
 * struct Point {
 *	int x;
 *	int y;
 * };
 */

class Solution {
public:
    /**
     * 返回牛牛所能得到的字典序最小的排列
     * @param n int整型 
     * @param m int整型 
     * @param perm int整型vector 
     * @param Pair Point类vector 
     * @return int整型vector
     */
    int fa[200005];
    int con[200005];
    int find(int x){
        if(fa[x]!=x){
            fa[x]=find(fa[x]);
        }
        return fa[x];
    }
    void merge(int x,int y){
        int fx=find(x);
        int fy=find(y);
        if(fx!=fy){
            fa[fy]=fx;
        }
    }
    int num[200005];
    vector<int> solve(int n, int m, vector<int>& perm, vector<Point>& Pair) {
        // write code here
        for(int i=1;i<=n;++i){
            fa[i]=i;
        }
        int cnt=0;
        for(int i=0;i<n;++i){
            num[++cnt]=perm[i];
        } 
        for(int i=0;i<m;++i){
            int l=Pair[i].x;
            int r=Pair[i].y;
            merge(l,r);
        }

        vector<int>ans;
        vector<int>kep[100005];
        for(int i=1;i<=n;++i){
            int f=find(i);
            kep[f].push_back(num[i]);
        }
        for(int i=1;i<=n;++i){
            sort(kep[i].begin(),kep[i].end());
        }
        for(int i=1;i<=n;++i){
            int f=find(i);
            ans.push_back(kep[f][con[f]]);
            con[f]++;
            //cout<
        }
        return ans;
    }
};