暑训day11 搜索进阶

上个专题网络流只勉强看懂了EK，Dinic并没有入手(不过看起来二者差不太多)，题也就做了两道，网络流的总结之后再说吧。

 这一天黄大佬讲了搜索，才发现简单的dfs,bfs外还有这么niupi的算法。

首先认识清楚一件事，“搜索”大多是暴力的，所以在搜索题中非常重要的一个概念就是状态数目。 比如：

1. 八皇后问题 8！
2. 19路围棋 3^361
3. 三阶魔方 4.3*10^19

当然小的状态数直接暴搜即可，而对于庞大的状态数目，就要采用一些优秀的算法来进行优化。包括状态压缩，状态转移复杂度，剪枝，和高效的搜索算法。

1. 状压dp
2. 状态转移时有精确覆盖，DancingLinks(将复杂度降为多项式时间)
3. 剪枝有很多种：可行性剪枝，最优化剪枝······（这里介绍Alpha-Beta剪枝
4. 高效的搜索算法：极大极小搜索，A*，IDA*等

A - Sudoku POJ - 2676

数独问题，还好时3*3*3*3的，直接暴力搜索+剪枝即可(标记走过的点，结束后回溯

#include<cstdio>
char s[10];
int num[9][9];
bool flag; 
bool tag(int n,int cur)
{
	int r=n/9;
	int c=n%9;
	for(int j=0;j<9;j++)
		if(num[r][j]==cur)
			return false;
	for(int j=0;j<9;j++)
		if(num[j][c]==cur)
			return false;
	int x=r/3*3;
	int y=c/3*3;
	for(int i=x;i<x+3;i++)
		for(int j=y;j<y+3;j++)
			if(num[i][j]==cur)
				return false;
	return true;
}
void DFS(int n)
{
	if(n>80||flag)
	{
		flag=true;
		return ;
	}
	if(num[n/9][n%9])
	{
		DFS(n+1);
		if(flag)
		return ;
	}
	else
	{
		for(int cur=1;cur<=9;cur++)
		{
			if(tag(n,cur))
			{
				num[n/9][n%9]=cur;
				DFS(n+1);
				if(flag)
				return ;
				num[n/9][n%9]=0;
			}
		}
	}
}
int main()
{   
    int T;
    scanf("%d", &T);
    while(T--)
    {
        flag = false;
        for(int i = 0; i < 9; i++) 
		{
			scanf("%s", s);
            for(int j = 0; j < 9; j++)
                num[i][j] = (s[j] - '0');
		}
        DFS(0);  
        for(int i = 0; i < 9; i++)
        {
            for(int j = 0; j < 9; j++)
                printf("%d", num[i][j]);
            printf("\n");      
        }
    }
}

G - Triangle War POJ - 1085 

这是一道对抗搜索题（也叫做零和博弈），游戏特点为双方每一步行动都会使自己利益最大化对手利益最小化，则博弈过程按搜索树展开后对Player A而言每一层为极大极小利益交替（B同理），解决该问题的方法为极大极小搜索算法，而其中状态数过于庞大就要应用Alpha-Beta剪枝进行优化（二者经常成对出现），每条边用二进制压缩，用 2^0 = 1 表示 edge(1, 2) 或 edge(2, 1)，用 2^1 = 2(即二进制10)表示 edge(2, 3) 或 edge(3, 2)，则构成三角形的该局面用 2^0 + 2^1 + 2^2 = 7 表示；

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int map[11][11]={
    {0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,1,0,0,0,0,0,0,0},
    {0,0,0,2,3,4,0,0,0,0,0},
    {0,1,2,0,0,5,6,0,0,0,0},
    {0,0,3,0,0,7,0,9,10,0,0},
    {0,0,4,5,7,0,8,0,11,12,0},
    {0,0,0,6,0,8,0,0,0,13,14},
    {0,0,0,0,9,0,0,0,15,0,0},
    {0,0,0,0,10,11,0,15,0,16,0},
    {0,0,0,0,0,12,13,0,16,0,17},
    {0,0,0,0,0,0,14,0,0,17,0}
};
int State=(1<<18)-1;
int tri[9]={7,152,52,352,34304,3200,71680,12544,155648};
int get_States(int state,int seg,int &cnt)
{
    int now=state|seg;
    for(int i=0;i<9;i++)
    {
        if((state&tri[i])!=tri[i]&&(now&tri[i])==tri[i])
            cnt++;
    }
    return now;
}
int MinSearch(int state,int alpha,int a,int b); 
int MaxSearch(int state,int beta,int a,int b);
int MinSearch(int state,int alpha,int a,int b)
{
    if(a>=5) return 1;
    if(b>=5) return -1;
    if(state==State) return a>b?1:-1;
    int ans=1;
    int reminds=(~state)&State;
    while(reminds)
    {
        int seg=reminds&(-reminds);
        int tb=b;
        int temp=get_States(state,seg,tb);
        int tp;
        if(tb>b)
            tp=MinSearch(temp,alpha,a,tb);
        else
            tp=MaxSearch(temp,ans,a,tb);
        ans=min(ans,tp);
        if(ans<=alpha) return ans;
        reminds-=seg;
    }
    return ans;
}
int MaxSearch(int state,int beta,int a,int b)
{
    if(a>=5) return 1;
    if(b>=5) return -1;
    if(state==State) return a>b?1:-1;
    int ans=-1;
    int reminds=(~state)&State;
    while(reminds)
    {
        int seg=reminds&(-reminds);
        int ta=a;
        int temp=get_States(state,seg,ta);
        int tp;
        if(ta>a)
            tp=MaxSearch(temp,beta,ta,b);
        else
            tp=MinSearch(temp,ans,ta,b);
        ans=max(ans,tp);
        if(ans>=beta) return ans;
        reminds-=seg;
    }
    return ans;
}
int main()
{
    int t,kase=0;
    scanf("%d",&t);
    while(t--)
    {
        int m;
        scanf("%d",&m);
        int x,y;
        int state=0;
        int a=0,b=0;
        int cnt=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&x,&y);
            int ta=a,tb=b;
            state=get_States(state,1<<map[x][y],(cnt&1)?b:a);
            if(ta==a&&tb==b) cnt++;
        }
        int ans;
        if(cnt&1) ans=MinSearch(state,-1,a,b);
        else ans=MaxSearch(state,1,a,b);
        printf("Game %d: %c wins.\n",++kase,ans==1?'A':'B');
    }
    return 0;
}

 

H - Play Game HDU - 4597 

其实是一道区间dp，本质上dp也就是搜索，只不过dp不需要重复计算已有的结果

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int maxn = 20 + 5;
 
int a[maxn];
int b[maxn];
int suma[maxn],sumb[maxn];
int dp[maxn][maxn][maxn][maxn];
 
int dfs(int al,int ar,int bl,int br)
{
    if(dp[al][ar][bl][br] != -1) return dp[al][ar][bl][br];
    dp[al][ar][bl][br] = 0;
    if(al < ar-1) dp[al][ar][bl][br] = a[al+1] + (suma[ar-1]-suma[al+1]+sumb[br-1]-sumb[bl]-dfs(al+1,ar,bl,br));
    if(al < ar-1) dp[al][ar][bl][br] = max(dp[al][ar][bl][br],a[ar-1] + (suma[ar-2]-suma[al]+sumb[br-1]-sumb[bl]-dfs(al,ar-1,bl,br)));
    if(bl < br-1) dp[al][ar][bl][br] = max(dp[al][ar][bl][br],b[bl+1] + (suma[ar-1]-suma[al]+sumb[br-1]-sumb[bl+1]-dfs(al,ar,bl+1,br)));
    if(bl < br-1) dp[al][ar][bl][br] = max(dp[al][ar][bl][br],b[br-1] + (suma[ar-1]-suma[al]+sumb[br-2]-sumb[bl]-dfs(al,ar,bl,br-1)));
    return  dp[al][ar][bl][br];
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        suma[0] = 0;sumb[0] = 0;
        for(int i = 1;i <= n;i++)
        {
            scanf("%d",&a[i]);
            suma[i] = suma[i-1] + a[i];
        }
        for(int i = 1;i <= n;i++)
        {
            scanf("%d",&b[i]);
            sumb[i] = sumb[i-1]+b[i];
        }
        memset(dp,-1,sizeof(dp));
        printf("%d\n",dfs(0,n+1,0,n+1));
    }
    return 0;
}

搜索题在比赛中毕竟要有超于常人的意志力，几百行代码家常便饭，debug难度也很大，任重道远。