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
",i,max(a,b));
                        }
                }
                printf("Case #%d:
%d
", T++, ans);
        }
        return 0;
}