2014百度之星 Party

Party

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 0    Accepted Submission(s): 0

Problem Description

　　B公司共有N个员工，但是并不是所有人都能和睦相处。在每一个人的心中都有一个潜在的对手，任何人都不能接受和他的对手同时参加B公司的聚餐。然而这种关系并不一定是对称的，也就是说，A把B视作自己的对手，而B所想的对手并不一定是A。
　　现在，B公司准备举办一次盛大的聚会，公司希望员工通过这次聚会获得尽可能多的快乐值。第i个员工的快乐值是一个大于0不大于100的整数，如果他参加聚餐，他就会获得的快乐值，如果他的对手参加聚餐，他的快乐值就为0。
　　但老板在安排聚餐时不知道如何解决这个问题，因此，他找到你帮忙计算这次聚会最多可以带来多少快乐值。

 

 

Input

　　输入数据的第一行是一个整数T，表示有T组测试数据。
　　每组数据的第一行包括一个整数N，表示共有N个员工。（约有500组数据N不大于500，约有10组数据N不大于100000）
　　第二行是N个用空格隔开的整数，第i个整数表示第i个员工的对手的编号。数据保证 x _i ∈ [1,N], 且 x _i <> i .
　　第三行也包含N个用空格隔开的整数，表示第i个员工能够获得的快乐值a _i。

 

 

Output

　　对于第k组数据，第一行输出Case #k:，第二行输出仅包含一个数，表示这次聚会最多可以带来多少快乐值。

 

 

Sample Input

1 8 2 7 1 8 4 2 3 5 50 30 40 40 50 10 70 60

 

 

Sample Output

Case #1: 190

Hint

在样例中，应选择1、6、7、8号员工。

解题报告：

将每个员工认为是图上的一个顶点，如果员工s的敌人是员工t，则s到t建立一条有向边。由于每个员工只有一个敌人，因此每个顶点的出度为1。所以整个图可以被拆分成多个连通子图，每个联调子图上只有一个环，可以分别对每个连通子图单独处理。

         考虑每个连通子图，找出环上的任意一条边s->t，去除这条边后，可以得到以s为根的一颗树，然后枚举t被选择或者不被选择的情况，分别做一轮树形DP。

假设dp[k][0]表示在节点k不被选择的情况下，以节点k为根节点的子树下能够选择出来的最大快乐值；dp[k][1]则表示节点k被选择的情况。那么可以得到

dp[k][0] = sum( max( dp[son][0], dp[son][1] ) ) (son是节点k的儿子节点)

dp[k][1] = sum( dp[son][0] ) + happy[k] (happy[k]表示节点k能够获得的快乐值)

         当t被选择情况下 max_value1= dp[0];当t不被选择情况下max_value2= max(dp[0], dp[1])；而每个连通子图的最优解是max(max_value1,max_value2)

         整体处理的时间复杂度为O(N)

解题代码：

#include<iostream>

#include<stdlib.h>

#include<string.h>

#include<algorithm>

#include<stdio.h>

#include<vector>

#include<queue>



using namespace std;



const int N = 100010;



int val[N],ru[N],vis[N],res[N][2];

vector<int>edge[N];

queue<int>que;



int main()

{

    int T = 1;

        int csnum;

        scanf("%d",&csnum);

        for(int cs=1;cs<=csnum;cs++)

        {

                int n;

                scanf("%d",&n);



                for(int i=1;i<=n;i++)

                {

                        edge.clear();

                        ru=0;

                        vis=0;

                }

                while(que.empty()==false)

                        que.pop();



                for(int i=1;i<=n;i++)

                {

                        int a;

                        scanf("%d",&a);

                        edge.push_back(a);

                        edge[a].push_back(i);

                        ru++;ru[a]++;

                }

                for(int i=1;i<=n;i++)

                {

                        scanf("%d",&val);

                        res[1]=val;

                        res[0]=0;

                }



                for(int i=1;i<=n;i++)

                {

                        if(ru==1)

                                que.push(i);

                }



                while(que.empty()==false)

                {

                        int x=que.front();

                        que.pop();

                        vis[x]=1;

                        for(int i=0;i<edge[x].size();i++)

                        {

                                int y=edge[x];

                                if(vis[y]==0)

                                {

                                        ru[y]--;

                                        if(ru[y]==1)

                                                que.push(y);



                                        res[y][1]+=res[x][0];

                                        res[y][0]+=max(res[x][1],res[x][0]);

                                }

                        }

                }



                int ans=0;

                for(int i=1;i<=n;i++)

                {

                        if(vis==0)

                        {

                                int rs[2][2];

                                rs[0][0]=rs[0][1]=rs[1][0]=res[0];

                                rs[1][1]=res[1];

                                int pre=i;

                                vis=1;



                                do{

                                        int x=-1;

                                        for(int j=0;j<edge[pre].size();j++)

                                        {

                                                x=edge[pre][j];

                                                if(vis[x]==0)

                                                        break;

                                        }

        //                                printf("%d-%d ",pre,x);

        //                                puts("");

                                        if(vis[x]==1)

                                                break;

                                        vis[x]=1;



                                        int nrs[2][2];

                                        for(int u=0;u<2;u++)

                                        {

                                                nrs[0]=max(rs[0],rs[1])+res[x][0];

                                                nrs[1]=rs[0]+max(res[x][0],res[x][1]);

                                        }

                                        for(int u=0;u<2;u++)

                                                for(int v=0;v<2;v++)

                                                        rs[v]=nrs[v];

                                        pre=x;

                                }while(true);



                                int a=max(rs[0][0],rs[0][1]);

                                int b=rs[1][0];

                                ans+=max(a,b);

                        //        printf("%d %d\n",i,max(a,b));

                        }

                }

                printf("Case #%d:\n%d\n", T++, ans);

        }

        return 0;

}

View Code