BZOJ 1040 [ZJOI2008]骑士

题目链接：传送门

很明显，读完题目的话
这个图有$n$个点，$n$条边，基环树啊
然后就想到了删边，转化成树来做
这个图不一定是联通的
所以要对每一个点都进行判断再$dfs$
由于每个人只有一条出边
所以每个联通块内有且只有一个环
$dfs$的时候找到第一个被访问两次的点
删掉那条边，断环为链
分别头上的两个点为根做树形$dp$
就变成了基础模型
相邻的两个点不能同时选
$f[i][0/1]$表示以$i$为根节点的子树选或不选$i$获得的最大价值（$0$不选$1$选）
$fr$为当前点，$ca$为枚举到的点，转移为：
$f[fr][0]+=max(f[ca][0],f[ca][1])$
$f[fr][1]+=f[ca][0]$
方程的意思很明显
当前点不选，后面的点选不选都可以
当前点选了，后面的点一定不能选
$dp$的时候把删掉的点特判
由于我建的双向图，所以还要记录前驱
最后注意开$long$ $long$
至此。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <complex>
#include <algorithm>
#include <climits>
#include <queue>
#include <map>
#include <vector>
#include <iomanip>
#define A 1000010
#define B 2010
#define ll long long

using namespace std;
struct node {
    int next, to;
}edge[A << 1];
int n, hate, w[A], del, root1, root2;
bool vis[A];
ll f[A][2], ans;
int head[A], num_edge = 1;
void add_edge(int from, int to) {
    edge[++num_edge].next = head[from];
    edge[num_edge].to = to;
    head[from] = num_edge;
}
void dp(int fr, int fa) {
    f[fr][1] = w[fr]; f[fr][0] = 0;
    for (int i = head[fr]; i; i = edge[i].next) {
        int ca = edge[i].to;
        if (ca == fa) continue;
        if (i == del or i == (del ^ 1)) continue;
        dp(ca, fr);
        f[fr][0] += max(f[ca][0], f[ca][1]);
        f[fr][1] += f[ca][0];
    }
}
void dfs(int fr, int fa) {
    vis[fr] = 1;
    for (int i = head[fr]; i; i = edge[i].next) {
        int ca = edge[i].to;
        if (ca == fa) continue;
        if (vis[ca]) {
            del = i;
            root1 = ca;
            root2 = fr;
            continue;
        }
        dfs(ca, fr);
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &w[i], &hate);
        add_edge(i, hate);
        add_edge(hate, i);
    }
    for (int i = 1; i <= n; i++) {
        if (vis[i]) continue;
        dfs(i, 0);
        dp(root1, 0);
        ll xx = f[root1][0];
        dp(root2, 0);
        ans += max(xx, f[root2][0]);
    }
    cout << ans << endl;
}