『CSU 1322』ZY‘s new company(线段树维护bfs序)

转载声明:http://blog.csdn.net/alpc_neverfarewell/article/details/39160735

题意:
zzy开了一家公司,然后他为公司制定了人事制度:为每个员工都定一个直接的上属(除了zzy自己),这样就把公司表示成了一个树形的人事关系图,树的最顶端就是zzy自己。如果a的直接上属是b则称a是b的一级下属,接下去的依次称为2级、3级……k级下属。

由于如zzy奇葩的想法,他将改变一部分员工的工资,方法依旧是将员工原来的工资异或一个数,得到新的工资。
(这是中文题意,不可能看不懂吧)

个人感想:
这道题目很有意思,就是有一个又有趣的思想,用线段树维护bfs序,然后通过最近公共祖先(LCA),加上二分就可以找到当前 老板 的c级员工的范围.

这道题还给了个重要的思想,就是区间异或和,这我也没接触过,一道题补了好多知识点,维护bfs序这个我是从来没想到过的,确实不会,
『CSU 1322』ZY‘s new company(线段树维护bfs序)_第1张图片
首先先做一遍bfs
我们就可以知道每个深度的区间范围
知道这个有有什么用?我们可以对深度范围进行二分,找到对应的父节点的c级员工节点范围并用线段树更新

例如 现在我要找2的 1级员工
我们知道 depth[2]+1==3
第3层的范围是 4-8.
那么我们就二分这个区间点,并且往上走c级
我们就要找到一个 parent[x][c]2 最左节点, 和parent[y][c]>2的左的y,然后y-1 就是2的最右节点了, 然后就可以用线段树维护
我觉得有点神奇,…只是我对这个理解不深啊,
其实我就看了一会转载的博客我就懂了…
我出的最大问题不在建树,只是二分,
因为有可能所查询的节点 根本没c级员工,那只是别人的位置有而已
那么我怎么二分出来 并且 判断这个区间(x,y)合法?
我一直习惯用(r-l>1) 进行二分,这样做有点难度就是 可能你2个点刚好相差1,所有两个位置都没检测,那还要特殊处理,那就好麻烦了…
所以啊,还是我修行不够啊…
挺好的一道题目,值得深思.

分析:线段树+二分+最近公共祖先

AC代码:

/* Author:GavinjouElephant
 * Title:
 * Number:
 * main meanning:
 *
 *
 *
 */


#include 
using namespace std;
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
//#include
//#include 
//#include 
//#include 
#define MaxN 0x7fffffff
#define MinN -0x7fffffff
#define lson 2*k
#define rson 2*k+1
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=1e5+10;
int Scan()//读入整数外挂.
{
    int res = 0, ch, flag = 0;

    if((ch = getchar()) == '-')             //判断正负
        flag = 1;

    else if(ch >= '0' && ch <= '9')           //得到完整的数
        res = ch - '0';
    while((ch = getchar()) >= '0' && ch <= '9' )
        res = res * 10 + ch - '0';
    return flag ? -res : res;
}
void Out(int a)    //输出外挂
{
    if(a>9)
        Out(a/10);
    putchar(a%10+'0');
}

int n,q;
class Node
{
public:
    int l;
    int r;
    int lazy;
    int c[30];
};
Node node[4*maxn];

int val[maxn];
int ancestor[30][maxn];
int start[maxn];
int end1[maxn];
int entry[maxn];
int rentry[maxn];
int depth[maxn];

vectorG[maxn];
int getAncestor(int a,int dist)
{
    for(int i=20; i>=0; i--)
    {
        if(dist & (1<>i)&1);
        }
        return ;
    }
    int mid=(l+r)/2;
    build(l,mid,lson);
    build(mid+1,r,rson);
    pushup(k);
}
void chang(int l,int r,int k,int v)
{
    if(l<=node[k].l&&node[k].r<=r)
    {
        for(int i=0; i<30; i++)
        {
            if(v&(1<mid)  chang(max(mid+1,l),r,rson,v);
    pushup(k);
}
ll getAns(int l,int r,int k)
{
    ll ans=0;
    if(l<=node[k].l&&node[k].r<=r)
    {
        for(int i=0; i<30; i++)
        {
            ans+=(long long) node[k].c[i]<mid)  ans+=getAns(max(mid+1,l),r,rson);
    return ans;
}
void bfs()//求bfs序
{
     queue q;

     int DEF=1;//时间戳

     q.push(1);
     depth[1]=1;

     while(!q.empty())
     {
         int s=q.front();
         q.pop();

         start[depth[s]]=min(start[depth[s]],DEF);
         end1[depth[s]]=max( end1[depth[s]],DEF);

         rentry[DEF]=s;
         entry[s]=DEF++;

         for(int j=0;j<(G[s].size());j++)
         {
             int son=G[s][j];
             depth[son]=depth[s]+1;
             q.push(son);
         }
     }
}

void init()
{
    for(int i=0; i<=n; i++) G[i].clear();
    memset(ancestor,-1,sizeof(ancestor));
    memset(start,0x3f,sizeof(start));
    memset(end1,0,sizeof(end1));
    memset(depth,0,sizeof(depth));
    memset(entry,0,sizeof(entry));
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("coco.txt","r",stdin);
    freopen("lala.txt","w",stdout);
#endif
    while(scanf("%d%d",&n,&q)!=EOF)
    {
        n++;
        init();

        for(int i=2; i<=n; i++)
        {
            scanf("%d%d",&ancestor[0][i],&val[i]);
            ancestor[0][i]++;
            G[ ancestor[0][i] ].push_back(i);
        }

        int li=log2(n)+1;
        for(int k=0; k+1 n || start[d] == INF)
            {
                if (op == 1)
                {
                    printf("-1\n");
                }
                continue;
            }

            int x, y;
            {
                int l = start[d], r = end1[d];
                int ans = end1[d] + 1;
                while (l <= r)
                {
                    int mid = (l + r) >> 1;
                    if (entry[getAncestor(rentry[mid], c)] >= entry[b])
                    {
                        ans = mid;
                        r = mid - 1;
                    }
                    else
                    {
                        l = mid + 1;
                    }
                }
                x = ans;
            }

            {
                int l = start[d], r = end1[d];
                int ans = end1[d] + 1;
                while (l <= r)
                {
                    int mid = (l + r) >> 1;
                    if (entry[getAncestor(rentry[mid], c)] > entry[b])
                    {
                        ans = mid;
                        r = mid - 1;
                    }
                    else
                    {
                        l = mid + 1;
                    }
                }
                y = ans - 1;
            }

            if (y < x)
            {
                if (op)
                {
                    printf("-1\n");
                }
                continue;
            }

            if (op == 0)
            {
                chang(x,y,1,v);
            }
            else
            {
                printf("%lld\n", getAns(x,y,1));
            }

        }


    }

    return 0;
}

你可能感兴趣的:(『数据结构与算法』)