暴力求解

　　我们经常说暴力出奇迹，但是往往我们选择的方法都是暴力模拟，可以说对其的优化基本为0，最近看了刘汝佳的暴力求解章，在此文中对暴力枚举的几个方向选择进行简单的归类。本章的算法主要是对解答树进行处理与剪枝，让搜索最优。

1. 直接枚举(纯暴力)
2. 枚举子集和排列
3. dfs+回溯
4. 状态空间搜索
5. 迭代加深搜索(IDA*)

---

直接枚举(纯暴力)

　　最基本的直接枚举但是这种算法往往枚举效率不高，对于数据较小或者部分数据点的情况下可以去卡点偷分，在这不在赘述。

---

枚举子集和排列

　　n个元素的子集有2ⁿ个，可以用递归的方法枚举。

　　第一个问题就是全排列问题，此处注意生成全排列时重复产生的问题，如（1，2，2，4，5）的全排列，同时也要学会STL中（next_permutation）的使用。

do{
    for(int i=0;i<n;i++)    printf("%d ",p[i]);
    printf("\n");
}    while(next_permutation(p,p+n));

　　第二个问题就是枚举子集，这下面三个枚举方法非常典型，在今年的蓝桥总赛上就非常适合偷分。

1. 增量构造法，每次选择一个元素往里添加。

   void print_subset(int n,int a[],int cur)
   {
       for(int i=0;i<cur;i++)    cout<<a[i]<<" ";
       cout<<endl;
       int s=cur?a[cur-1]+1:0;
       for(int i=s;i<n;i++)
       {
           a[cur]=i;
           print_subset(n,a,cur+1);
       }
    } 

2. 位增量法，用tar标记是否出现元素。

   void print_subset(int n,int a[],int cur)
   {
       if(cur==n)
       {
           for(int i=0;i<cur;i++)    if(a[i]) printf("%d ",i);
           cout<<"\n";
           return;    
       }
       a[cur]=1;    print_subset(n,a,cur+1);
       a[cur]=0;    print_subset(n,a,cur+1);    
   }

3. 二进制法，利用移运算进行求解，适合数据较小时的情况。

   void print_subset(int n, int s){
       for(int i=0;i<n;i++)
           if(s&(1<<i))    printf("%d",i);
           printf("\n");
   }

---

dfs+回溯

　　可以把这个算法理解为在递增的过程中进行检查(剪枝)，从而减少没必要的枚举。

　　那个例题进行讲解（八皇后问题）：

　　分析一下解答树，如果完全模拟子集的大小C⁸₆₄=4.425*10⁹显然是一个不完美的算法，因此当我们放入不了的时候即剪枝。

void f(int x,int a[])
{
    if(x==n+1)
        if(ans<=3)
        {
            for(int ii=1;ii<=n;ii++)    cout<<a[ii]<<" ";
            cout<<"\n";
        }
    else{
        for(int i=1;i<=n;i++)
        {
            int left,right;
            left=x+i-1;
            right=x+n-i;
            if((!y[i])&&(!l[left])&&(!r[right]))
            {
                y[i]=l[left]=r[right]=1;    a[x]=i;
                f(x+1,a);    y[i]=l[left]=r[right]=0;
            }
        }
    }
}

这就是一个回溯的入门题，以下是典型的例题：

1. 搜索对象的选取(天平难题)
2. 最优性剪枝(带宽)
3. 减少无用功(困难的串)

---

状态空间搜索

　　此算法经常和图论结合在一起，解法是确定搜索空间，确定搜索方式，确定排重方法。

　　以八数码问题为例子，首先确定搜索空间与方法我们以空格为移动点进行移动，这类大的搜索问题我们不尽量不用dfs来进行搜索，防止爆栈的情况。

int bfs()
{
    init_lookup_table();
    int front=1,rear=2;
    while(front<rear){
        state &s=st[front];
        if(memcmp(goal,s,sizeof(s))==0)    return front;
        int z;
        for(z=0;z<9;z++) if(!s[z]) break;
        int x=z/3,y=z%3;
        for(int d=0;d<4;d++){
            int newx=x+dx[d];
            int newy=y+dy[d];
            int newz=newx*3+newy;
            if(newx>=0&&newx<3&&newy>=0&&newy<3){
                state &t=st[rear];
                memcpy(&t,&s,sizeof(s));
                t[newz]=s[z];
                t[z]=s[newz];
                dist[rear]=dist[front]+1;
                if(try_to_insert(rear))    rear++;
            }
        }
        front++;
    }
    return 0;
 }

其次选择排重方式，再次介绍三种典型的排重方式：

1. STL

   set<int> vis;
   void init_lookup_table()    {vis.clear();}
   int try_to_insert(int s){
       int v=0;
       for(int i=0;i<9;i++)    v=v*10+st[s][i];
       if(vis.count(v))    return 0;
       vis.insert(v);
       return 1;
   }

2. hash

   const int hashsize=1000003;
   int head[hashsize],next[maxstate];
   void init_lookup_table(){memset(head,0,sizeof(head));}
   int hash(State&s){
       int v=0;
       for(int i=0;i<9;i++)    v=v*10+s[i];
       return v%hashsize;
   }
   int try_to_insert(int s){
       int h=hash(st[s]);
       int u=head[h];
       while(u){
           if(memcmp(st[u],st[s],sizeof(st[s]))==0)    return 0;
           u=next[u];    
       }
       next[s]=head[h];
       head[h]=s;
       return 1;
   }

3. 编解码

   int vis[362880],fact[9]; 
   void init_lookup_table(){
       fact[0]=1;
       for(int i=1;i<9;i++)    fact[i]=fact[i-1]*i;
   }
   int try_to_insert(int s){
       int code=0;
       for(int i=0;i<9;i++){
           int cnt=0;
           for(int j=i+1;j<9;j++)    if(st[s][j]<st[s][i]) cnt++;
           code+=fact[8-i]*cnt;
       }
       if(vis[code])    return 0;
       return vis[code]=1;
   }

   典型例题：1.Dijkstra隐式图(倒水问题)　　2.双向bfs，A*(万圣节后的早晨)

---

IDA*

　　这个算法一般比较少用，用在没有上界或者解答树非常恐怖的时候，我们利用预估函数和逐渐放大答案的方式进行搜索。

　　其中以埃及分数问题最为典型，我们把组成的分数作为上界进行扩展。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 1e6+10;
LL maxd,a,b;
LL ans[maxn],v[maxn];
LL get_first(LL xa,LL xb)    {return xb/xa+1;}
bool better(int d)
{
    for(int i=d;i>=0;i--)
        if(v[i]!=ans[i])
            return ans[i]==-1||v[i]<ans[i];
    return false;
}
bool dfs(int d,LL from,LL aa,LL bb)
{
    if(d==maxd){
        if(bb%aa)    return false;
        v[d]=bb/aa;
        if(better(d))    memcpy(ans,v,sizeof(LL)*(d+1));
        return true;
    }
    bool ok=false;
    from=max(from,get_first(aa,bb));
    for(int i=from;;i++){
        if(bb*(maxd+1-d)<=i*aa)    break;
        v[d]=i;
        LL b2=bb*i;
        LL a2=aa*i-bb;
        LL g=__gcd(a2,b2);
        if(dfs(d+1,i+1,a2/g,b2/g))    ok=true;
    }
    return ok;
}
int main()
{
    scanf("%lld%lld",&a,&b);
    int ok=0;
    for(maxd=1;;maxd++)
    {
        memset(ans,-1,sizeof(ans));
        if(dfs(0,get_first(a,b),a,b))    {ok=1;    break;}
        }
    printf("%lld/%lld=",a,b);
    int first=1;
    for(int i=0;i<=maxd;i++)
        if(~ans[i]){
            if(first)    first=0;
            else    printf("+");
            printf("1/%lld",ans[i]);
        }
    return 0;
}

典型例题：编辑书稿

---

　　从整体上来说这一章算法是一个比较暴力的算法但在剪枝优化上，代码考验上还是非常值得深究的。