sicily 1219（记忆化搜索）

题目链接：sicily 1219

解题思路：
博弈题，用搜索来做。但是，如果用普通的搜索来做的话，是会超时的——复杂度大约是O( n^n )，所以需要采用记忆化搜索的方法（其实差不多就是动态规划了，但是这里是树形DP）。
状态：
用集合S表示现在树的状态，i 表示现在轮到谁进行砍边，dp[ S ][ i ]表示最优值。集合S可以用二进制来表示，即001表示现在还剩下第0条边。
状态转移：
1）A的目标是取最大值，B的目标是取最小值，我们在推导当前状态的最优解时，需要分两种情况考虑！即A得维护较大值，B维护较小值。
2）需要考虑没有边可以砍的情况——在当前玩家无法更新的情况下，直接寻找另一个玩家的解。
预处理：
一切为了时间——题目存在同时砍多条边的情况（只得到离根最近的一条边的值），所以我们可以在搜索前找到每一条边的影响边，即砍掉这条边之后什么边会消失！

代码：

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f

using namespace std;

int n,c[25][25],w[25][25],v[25];
int dp[1<<20][2],flag[25],pre[25];

void dfs(int index)                     //预处理 
{
    v[index]=1;
    flag[index]|=(1<<(index-1));        //加上自身这个结点（使用后继结点的索引作为边的编号） 
    for(int i=1;i<n;i++)
    {
        if(!v[i]&&w[index][i]!=0)
        {
            dfs(i);
            flag[index]|=flag[i];
            pre[i]=index;
        }
    }
}

int sol(int index,int player)           //记忆化搜索 
{
    if(!index) return 0;
    if(dp[index][(player+1)/2]!=INF)    //已经搜索过的 
        return dp[index][(player+1)/2];

    int maxx=-INF,minx=INF,new_index,tmp;
    for(int i=1;i<n;i++)                //尝试砍去剩下的边 
    {
        if(index&(1<<(i-1)))
        {
            if(player!=c[pre[i]][i])
                continue;

            new_index=index&~flag[i];
            tmp=sol(new_index,player*-1);

            maxx=max(maxx,w[pre[i]][i]+tmp);    //A玩家 
            minx=min(minx,w[pre[i]][i]+tmp);    //B玩家 
        }
    }

    if(player==1)                           //A玩家 
    {
        if(maxx==-INF)                      //找不到可以砍的边 
            maxx=sol(index,-player);
        dp[index][(player+1)/2]=maxx;
    }
    if(player==-1)                          //B玩家 
    {
        if(minx==INF)                       //找不到可以砍的边 
            minx=sol(index,-player);
        dp[index][(player+1)/2]=minx;
    }

    return dp[index][(player+1)/2];
}

int main()
{
    int index;
    while(~scanf("%d",&n))
    {
        n++;
        memset(w,0,sizeof(w));
        memset(c,0,sizeof(c));
        memset(v,0,sizeof(v));

        int x,y,cc,ww;
        for(int i=1;i<n;i++)
        {
            scanf("%d %d %d %d",&x,&y,&cc,&ww);
            c[x][y]=c[y][x]=cc;
            w[x][y]=w[y][x]=ww*cc;          //红边取正，黑边取负 
        }

        pre[0]=-1,dfs(0);                   //预处理 
        flag[0]=0;

        memset(dp,INF,sizeof(dp));

        int ans=sol((1<<(n-1))-1,1);
        printf("%d\n",ans);
    }

    return 0;
}

总结：
挺典型的记忆化搜索的题目，而这道题最大的亮点是可以用二进制来优化时间复杂度。果然太久没做题了有点生疏了，想起今年的校赛，确实很可惜，明年一定要打进省赛！