codevs 1423 骑士

题目描述 Description

Z国的骑士团是一个很有势力的组织，帮会中汇聚了来自各地的精英。他们劫富济贫，惩恶扬善，受到社会各界的赞扬。

最近发生了一件可怕的事情，邪恶的Y国发动了一场针对Z国的侵略战争。战火绵延五百里，在和平环境中安逸了数百年的Z国又怎能抵挡的住Y国的军队。于是人们把所有的希望都寄托在了骑士团的身上，就像期待有一个真龙天子的降生，带领正义打败邪恶。

骑士团是肯定具有打败邪恶势力的能力的，但是骑士们互相之间往往有一些矛盾。每个骑士都有且仅有一个自己最厌恶的骑士（当然不是他自己），他是绝对不会与自己最厌恶的人一同出征的。

战火绵延，人民生灵涂炭，组织起一个骑士军团加入战斗刻不容缓！国王交给了你一个艰巨的任务，从所有的骑士中选出一个骑士军团，使得军团内没有矛盾的两人（不存在一个骑士与他最痛恨的人一同被选入骑士军团的情况），并且，使得这支骑士军团最具有战斗力。

为了描述战斗力，我们将骑士按照1至N编号，给每名骑士一个战斗力的估计，一个军团的战斗力为所有骑士的战斗力总和。

输入描述 Input Description

第一行包含一个正整数N，描述骑士团的人数。

接下来N行，每行两个正整数，按顺序描述每一名骑士的战斗力和他最痛恨的骑士。

输出描述 Output Description

应包含一行，包含一个整数，表示你所选出的骑士军团的战斗力。

样例输入 Sample Input

3
10 2
20 3
30 1

样例输出 Sample Output

30

数据范围及提示 Data Size & Hint

对于30%的测试数据，满足N ≤  10；

对于60%的测试数据，满足N ≤  100；

对于80%的测试数据，满足N ≤  10 000。

对于100%的测试数据，满足N ≤ 1 000 000，每名骑士的战斗力都是不大于   1 000 000的正整数。

---

　　这道题很容易就可以想到树形dp，但是会出现环，就先把树上进行树形动规，然后再在

环上进行dp，环上的dp就从一个地方切开，然后增加一个状态，选第一个点和不选第一个点

关于树形dp还是再说两句，用f[i]表示i骑士选的最大战斗力（仅限这棵子树），g[i]表示不选

i骑士

　　得到了方程:

　　f[i] = sum{g[son[i][j]]};

　　g[i] = sum{max(g[son[i][j]], f[son[i][j]])};

（注:son[i][j]表示i节点的第j个子节点的编号，实际编程中可直接用存图的方式来储存）

---

Code

/**
 * codevs.cn
 * Problem#1423
 * Accepted
 * Time:1478ms
 * Memory:58768k
 */
#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<vector>
using namespace std;
typedef bool boolean;
template<typename T>
void readInteger(T& u){
    char x;
    while(!isdigit((x = getchar())));
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 3) + (u << 1) + x - '0');
    ungetc(x, stdin);
}
typedef class Edge{
    public:
        int end;
        int next;
        Edge(const int end = 0, const int next = 0):end(end),next(next){}
}Edge;
int ce;
int *h;
Edge* edge;
inline void addEdge(int from, int end){
    edge[++ce] = Edge(end, h[from]);
    h[from] = ce;
}
int cc;
int *visitID;
int *exitID;
boolean *visited;
boolean *inStack;
int entryed;
stack<int> sta;
vector<int> *start;
void getSonMap(int end){
    vector<int> buf;
    int now = -1;
    int exits = 0;
    while(now != end){
        now = sta.top();
        inStack[now] = false;
        exits++;
        buf.push_back(now);
        sta.pop();
    }
    if(exits > 1){
        for(int i = 0; i < exits; i++){
            start[cc].push_back(buf[i]);
        }
        cc++;
    }
}
void Tarjan(const int pi){
    int index = h[pi];
    visitID[pi] = ++entryed;
    exitID[pi] = visitID[pi];
    visited[pi] = true;
    inStack[pi] = true;
    sta.push(pi);
    while(index != 0){
        if(!visited[edge[index].end]){
            Tarjan(edge[index].end);
            exitID[pi] = min(exitID[pi],exitID[edge[index].end]);
        }else if(inStack[edge[index].end]){
            exitID[pi] = min(exitID[pi],visitID[edge[index].end]);
        }
        index = edge[index].next;
    }
    if(exitID[pi] == visitID[pi]){
        getSonMap(pi);
    }
}
int n;
int *v;
long long *f;
long long *g;
inline void init(){
    readInteger(n);
    v = new int[(const int)(n + 1)];
    edge = new Edge[(const int)(n + 1)];
    h = new int[(const int)(n + 1)];
    visited=new boolean[(const int)(n+1)];
    visitID=new int[(const int)(n+1)];     
    exitID =new int[(const int)(n+1)];      
    inStack=new boolean[(const int)(n+1)];
    start = new vector<int>[(const int)(n / 2 + 1)];
    f = new long long[(const int)(n + 1)];
    g = new long long[(const int)(n + 1)];
    memset(h, 0, sizeof(int) * (n + 1));
    memset(visited,false,sizeof(boolean)*(n+1));
    memset(inStack,false,sizeof(boolean)*(n+1)); 
    for(int i = 1,e; i <= n; i++){
        readInteger(v[i]);
        readInteger(e);
        addEdge(e, i);
    }
}
void tree_dp(int node, int last){
    f[node] = v[node];
    g[node] = 0;
    for(int i = h[node]; i != 0; i = edge[i].next){
        int e = edge[i].end;
        if(e == last || !(visited[e]))    continue;
        tree_dp(e, node);
        f[node] += g[e];
        g[node] += max(f[e], g[e]);
    }
}
#define int long long
long long *fc[2];
long long *gc[2];
long long** c[4] = {&fc[0], &fc[1], &gc[0], &gc[1]};
int circle_dp(int index){
    int result = 0;
    for(int i = 0; i < 4; i++){
        *c[i] = new int[(const int)(start[index].size() + 1)];
        memset(*c[i], 0, sizeof(int) * (start[index].size() + 1));
    }
    for(int k = 0; k < 2; k++){
        fc[k][1] = (k == 0)?(g[start[index][0]]):(f[start[index][0]]);
        gc[k][1] = (k == 1)?(g[start[index][0]]):(g[start[index][0]]);
        for(int i = 2; i <= start[index].size(); i++){
            fc[k][i] = gc[k][i - 1] + f[start[index][i - 1]];
            gc[k][i] = max(gc[k][i - 1], fc[k][i - 1]) + g[start[index][i - 1]];
        }
        int e = start[index][start[index].size() - 1];
        int s = start[index].size();
        fc[k][s] = (k == 0)?(f[e] + gc[k][s - 1]):(0);
        gc[k][s] = (k == 1)?(g[e] + max(gc[k][s - 1], fc[k][s - 1])):(0);
        result = max(result, fc[k][s]);
        result = max(result, gc[k][s]);
    }
    return result;
}
#undef int
int main(){
    init();
    for(int i = 1; i <= n; i++)
        if(!visited[i])
            Tarjan(i);
    delete[] visitID;
    delete[] exitID;
    delete[] inStack;
    memset(visited, true, sizeof(boolean) * (n + 1));
    for(int k = 0; k < cc; k++)
        for(int i = 0; i < start[k].size(); i++){
            visited[start[k][i]] = false;
        }
    for(int k = 0; k < cc; k++)
        for(int i = 0; i < start[k].size(); i++)
            tree_dp(start[k][i], 0);
    delete[] visited;
    long long result = 0;
    for(int k = 0; k < cc; k++)
        result += circle_dp(k);
    cout<<result;
    return 0;
}

　　写得有点复杂，不过这都不重要（笑）

第一次ac省选的（水）题，好开心