ural False Mirrors (状态压缩+记忆化搜索)

http://acm.timus.ru/problem.aspx?space=1&num=1152

有n个阳台围城一圈，每个阳台都有若干个怪兽，一次可以打三个相邻的阳台上的怪兽，它们就会全部死去，但攻击者会受到没有死去怪兽的攻击，每个怪兽的攻击是1unit，问最后攻击者受到的最小伤害。

n <= 20，可以直接dfs过去。

1次WA，1次TLE。

WA是没看透题意，我判断的递归终止的条件是怪兽数目小于等于3，这是不对的，就算怪兽数目小于等于3，也不一定能一次打完，因为它只能打连续的怪兽，若两个怪兽之间的距离大于等于2，那么还需要一次才能打完。

TLE因为没加剪枝，dfs的过程中一旦发现已受攻击值大于最优值，就返回。

#include <stdio.h>
#include <iostream>
#include <map>
#include <set>
#include <list>
#include <stack>
#include <vector>
#include <math.h>
#include <string.h>
#include <queue>
#include <string>
#include <stdlib.h>
#include <algorithm>
#define LL __int64
#define eps 1e-12
#define PI acos(-1.0)
#define PP pair<LL,LL>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1000;
const int mod = 1000000009;

int a[22],vis[22];
int Min;
int n;
void dfs(int num,int sum,int att)
{
	if(att >= Min) //TLE的关键！
		return;
	if(num == 1)
	{
		Min = min(Min,att);
		return;
	}
	//判断没死的怪兽的位置是否相邻，只有相邻递归才结束
	else if(num == 2)
	{
		int p[3],cnt=0;
		for(int i = 1; i <= n; i++)
			if(!vis[i])
				p[++cnt] = i;
		if(p[2] - p[1] <= 1 || p[2]-p[1] == n-1)
		{
			Min = min(Min,att);
			return;
		}
	}
	else if(num == 3)
	{
		int p[3],cnt = 0;
		for(int i = 1; i <= n; i++)
		{
			if(!vis[i])
			{
				if(i <= n-2 && !vis[i+1] && !vis[i+2])
				{
					Min = min(Min,att);
					return;
				}
				else if(!vis[n-1] && !vis[n] && !vis[1])
				{
					Min = min(Min,att);
					return;
				}
			}
		}
	}
	for(int i = 1; i <= n; i++)
	{
		if(!vis[i])
		{
			int tmp = 0,f1 = 0,f2 = 0,t;
			vis[i] = 1;
			tmp += a[i];
			if(i > 1 && !vis[i-1])
			{
				vis[i-1] = 1;
				tmp += a[i-1];
				f1 = 1;
			}
			else if(i == 1 && !vis[n])
			{
				vis[n] = 1;
				tmp += a[n];
				f1 = 1;
			}
			if(i < n && !vis[i+1])
			{
				vis[i+1] = 1;
				tmp += a[i+1];
				f2 = 1;
			}
			else if(i == n && !vis[1])
			{
				vis[1] = 1;
				tmp += a[1];
				f2 = 1;
			}

			t = sum - tmp;
			dfs(num-1-f1-f2,t,att+t);
			vis[i] = 0;
			if(i > 1 && f1 == 1)
				vis[i-1] = 0;
			else if(i == 1 && f1 == 1)
				vis[n] = 0;
			if(i < n && f2 == 1)
				vis[i+1] = 0;
			else if(i == n && f2 == 1)
				vis[1] = 0;
		}
	}
}

int main()
{
	int sum;
	while(~scanf("%d",&n))
	{
		sum = 0;
		for(int i = 1; i <= n; i++)
		{
			scanf("%d",&a[i]);
			sum += a[i];
		}
		Min = INF;
		memset(vis,0,sizeof(vis));
		dfs(n,sum,0);
		printf("%d\n",Min);
	}
	return 0;
}

又换了一种新姿势，因为n<=20，且每个怪物在一种状态下只有0和1两个选择，所以共有(1<<n)-1种状态，然后记忆化搜索。

#include <stdio.h>
#include <iostream>
#include <map>
#include <set>
#include <list>
#include <stack>
#include <vector>
#include <math.h>
#include <string.h>
#include <queue>
#include <string>
#include <stdlib.h>
#include <algorithm>
#define LL __int64
#define eps 1e-12
#define PI acos(-1.0)
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 50010;

int n,num[22];
int dp[(1<<20)+10];

int dfs(int sta)
{
    if(dp[sta] != INF)
        return dp[sta];
    int ss,a,b;
    for(int i = 1; i <= n; i++)
    {
        if(sta&(1<<(i-1)))
        {
        	ss = sta;
            a = (i == 1?n:i-1);
            b = (i == n?1:i+1);
            ss -= (1<<(i-1));
            if(ss&(1<<(a-1)))
                ss -= (1<<(a-1));
            if(ss&(1<<(b-1)))
                ss -= (1<<(b-1));
            int tmp = 0;
            for(int j = 1; j <= n; j++)
                if(ss & (1<<(j-1)) )
                    tmp += num[j];
			dp[sta] = min(dp[sta],dfs(ss)+tmp);
        }
    }
    return dp[sta];
}

int main()
{
    while(~scanf("%d",&n))
    {
        for(int i = 1; i <= n; i++)
            scanf("%d",&num[i]);
        memset(dp,INF,sizeof(dp));
        dp[0] = 0;
        printf("%d\n",dfs((1<<n)-1));
    }
    return 0;
}