SOJ 1219. 新红黑树

解题技巧：

　　1.输入的树可能不是根据从根节点到子节点的顺序输入的。

　　　　例如：

　　　　　　输入可能是：

　　　　　　3

　　　　　　1 0 1 100

　　　　　　2 1 -1 200

　　　　　　2 3 1 400

　　　所以一个较笨的方法是：先存成矩阵的形式，再转换成邻接链表的形式。

　　2.接着是一个记忆化搜索的过程。因为树枝数n<=20，即节点数<=21，故可以借助位运算的技巧，将一个树的状态压缩成一个整数。

　　　　树的状态是指树中哪些节点是有效可访问的。

　　　　dp[i][j]记录的是树的状态为i时，j先剪树的使得D满足j的期望的最优值.对剪红树枝的A来说，D越大越好；对剪黑树枝的B来说，D越小越好。

　　3.注意在计算dp[i][j]时，如果当前j不能剪树枝，则证明状态为i的树中，所有树枝都是另外一种颜色（j不能剪的颜色）。

代码如下：

#include <cstdio>
#include <vector>
#include <queue>
#include <climits>
#include <algorithm>
using namespace std;

struct Edge {
    int to;
    int color;  // color = 0 -> red  | color = 1 -> black
    int weight;
    Edge(int t = 0, int c = 0, int w = 0) : to(t), color(c), weight(w) {}
};

struct Attribute {
    bool used;
    int color;
    int weight;
};

const int maxn = 20;
const int states = 1 << 21;
const int INF = INT_MAX;
Attribute m[maxn + 1][maxn + 1];

vector<Edge> matrix[maxn + 1];

bool visited[maxn + 1];
int n;

int dp[states][2];  // dp[i][j] 表示状态为i的树j先走的D的最大值
int subtree[maxn + 1];  // 子树的状态

void init() {
    for (int i = 0; i < maxn + 1; ++i) {
        for (int j = 0; j < maxn + 1; ++j)
            m[i][j].used = false;
        matrix[i].clear();
        visited[i] = false;
        subtree[i] = 0;
    }
    for (int i = 0; i < states; ++i) dp[i][0] = dp[i][1] = INF;
    dp[1][0] = dp[1][1] = 0;
}

void transform(int cur) {
    visited[cur] = true;
    vector<Edge> &vt = matrix[cur];
    for (int i = 0; i <= n; ++i) {
        if (!visited[i] && m[cur][i].used) {
            vt.push_back(Edge(i, m[cur][i].color, m[cur][i].weight));
            transform(i);
        }
    }
}

int subTree(int root) {
    vector<Edge> &vt = matrix[root];
    int state = 1 << root;
    for (int i = 0; i < vt.size(); ++i) {
        Edge &e = vt[i];
        state += subTree(e.to);
    }
    return subtree[root] = state;
}

int DP(int state, int color) {
    if (dp[state][color] != INF) return dp[state][color];
    
    if (color == 0) dp[state][color] = -INF;
    else dp[state][color] = INF;

    int tot[2] = { 0, 0 };
    bool canCut = false;

    queue<int> que;
    que.push(0);
    while (!que.empty()) {
        int cur = que.front(); que.pop();
        vector<Edge> &vt = matrix[cur];
        for (int i = 0; i < vt.size(); ++i) {
            Edge &e = vt[i];
            if (((1 << e.to) & state) == 0) continue;
            que.push(e.to);
            if (e.color == color) {
                canCut = true;  // 表示需要修剪的颜色为color时，可以找到可剪的树枝
                int weight = (color == 0 ? e.weight : -e.weight);
                int st = subtree[e.to]; // 包括e.to
                int next_state = state & (~st);
                int next_color = (color + 1) % 2;
                if (color == 0) {
                    dp[state][color] = max(dp[state][color], DP(next_state, next_color) + weight);
                } else {
                    dp[state][color] = min(dp[state][color], DP(next_state, next_color) + weight);
                }
            }
            tot[e.color] += (e.color == 0 ? e.weight : -e.weight);
        }
    }
    if (!canCut) dp[state][color] = tot[(color + 1) % 2];   // 如果全部都是另外一种情况，则另外一种情况必然全选
    return dp[state][color];
}

int main() {
    while (scanf("%d", &n) != EOF) {
        init();

        // 读入新红黑树
        int node1, node2, color, weight;
        for (int i = 0; i < n; ++i) {
            scanf("%d%d%d%d", &node1, &node2, &color, &weight);
            color = color == -1 ? 1 : 0;    // color = 0 -> red | color = 1 -> black
            m[node1][node2].used = m[node2][node1].used = true;
            m[node1][node2].color = m[node2][node1].color = color;
            m[node1][node2].weight = m[node2][node1].weight = weight;
        }

        // 转换新红黑树->邻接链表
        transform(0);
        // 构造每个子树的状态
        subTree(0);

        // 使用算法查找红黑树状态为（111...111），A均（砍红树）现行的D的最大值
        int state = (1 << (n + 1)) - 1;
        printf("%d
", DP(state, 0));
    }
    return 0;
}