埃及分数&&The Rotation Game&&骑士精神——IDA*

IDA*：非常好用的搜索，可以解决很多深度浅，但是规模大的搜索问题。

估价函数设计思路：观察一步最多能向答案靠近多少。

埃及分数

题目大意：

　　给出一个分数，由分子a 和分母b 构成，现在要你分解成一系列互不相同的单位分数（形如：1/a，即分子为1），要求：分解成的单位分数数量越少越好，如果数量一样，最小的那个单位分数越大越好。

如：

　　19/45 = 1/3 + 1/12 + 1/180;

　　19/45 = 1/5 + 1/6 + 1/18;

　　以上两种分解方法都要3个单位分数，但下面一个的最小单位分数1/18比上一个1/180大，所以第二个更优。

题解：
dfs直接搜爆炸，因为深度无限。

bfs爆炸，空间不行。

所以，采用有深度限制的，并且不耗费空间的迭代加深搜索。

深度即分数的个数。

配合一下A*思想。

剪枝：

1.每次一步到达小于剩余分数的最小分母。

return b/a+1

2.如果当前可以选择的分数（已经是最大的）*剩下的步数<剩下的分数，return （A*思想）

3.如果只剩最后一步，直接判断能否取到。

对于不能取的处理，开一个数组记录。>1000都可以取的。

分数运算，手推式子。注意约分

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=+;
ll a,b;
int k,T;
bool fl;
ll ans[N];
ll mem[N];
bool no[N];
int dp;
ll getfirst(ll a,ll b){
    return b/a+;
}
bool cmp1(ll s1,ll m1,ll s2,ll m2){//s1/m1 > s2/m2 ?
    return (ll)s1*m2>(ll)m1*s2;
}
bool cmp2(ll s1,ll m1,ll s2,ll m2){//s1/m1 >= s2/m2 ?
    return (ll)s1*m2>=(ll)m1*s2;
}
ll gcd(ll a,ll b){
    return b?gcd(b,a%b):a;
}
void sub(ll &s1,ll &m1,ll s2,ll m2){
    s1=s1*m2-s2*m1;
    m1=m1*m2;
    ll g=gcd(s1,m1);
    s1/=g;
    m1/=g;
}
bool better(){
    for(int i=dp;i>=dp;i--){
        if(mem[i]!=ans[i]){
            //cout<<mem[i]<<" "<<ans[i]<<endl;
            return (ans[i]==)||(mem[i]<ans[i]);
        }
    }
    return false;
}
void dfs(int now,ll lim,ll rs,ll rm){
    //if(dp<4) cout<<now<<" "<<lim<<" "<<rs<<" "<<rm<<endl;
    if(now==dp){
        if(rs==){
            if(rm<lim) return;
            //if(rm<=1000&&no[rm]) return;
            fl=true;
            //cout<<" ok "<<endl;
            mem[dp]=rm;
            if(better()){
            ///cout<<"better "<<endl;
                for(int i=1;i<=dp;i++){
                    //cout<<mem[i]<<" ";
                    ans[i]=mem[i];
                }//cout<<endl;
            }
            mem[dp]=;
        }
        return;
    }
    lim=max(lim,getfirst(rs,rm));
    for(int i=lim;;i++){
        if(cmp1(rs,rm,(dp-now+),i)) return;
            if(cmp2(rs,rm,,i)){
                ll hs=rs,hm=rm;
                sub(hs,hm,,i);
                mem[now]=i;
                dfs(now+,i+,hs,hm);
                mem[now]=;
            }
    }
}
int main(){
        scanf("%lld%lld",&a,&b);
        int t;
        for(int i=;i<=k;i++){
            scanf("%d",&t);
            no[t]=;
        }
        fl=false;
        while(!fl){
            dp++;
            //if(dp<4) cout<<dp<<endl;
            dfs(,,(ll)a,(ll)b);
        }
        for(int i=;i<=dp;i++){
            printf("%lld ",ans[i]);
        }
    return ;
}

The Rotation Game

每次8种选择吃不消。

迭代加深直接做。

A*估价：中间8个数，最多的那一个一次转动最多多一个。如果中间的8个最多的那一个和8的差距比剩余步数多，return

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=;
int mp[N][N];
int st[N][N];
char sta[],top;
char ans[],sum;
int dp,num;
bool fl;
int cnt[];
int fan[]={,,,,,,,,};
int fin(){
    cnt[]=cnt[]=cnt[]=;
    for(int i=;i<=;i++)
        for(int j=;j<=;j++)
            cnt[mp[i][j]]++;
    if(cnt[]==) return ;
    if(cnt[]==) return ;
    if(cnt[]==) return ;
}
int che(){
    cnt[]=cnt[]=cnt[]=;
    for(int i=;i<=;i++){
        for(int j=;j<=;j++){
            cnt[mp[i][j]]++;
        }
    }
    int big=max(cnt[],max(cnt[],cnt[]));
    return -big;
}
void mvh(int d){
    if(d==){
        int tmp=mp[][];
        for(int i=;i>=;i--) mp[][i]=mp[][i-];
        mp[][]=tmp;
    }
    else if(d==){
        int tmp=mp[][];
        for(int i=;i>=;i--) mp[][i]=mp[][i-];
        mp[][]=tmp;
    }
    else if(d==){
        int tmp=mp[][];
        for(int i=;i<=;i++) mp[][i]=mp[][i+];
        mp[][]=tmp;
    }
    else{
        int tmp=mp[][];
        for(int i=;i<=;i++) mp[][i]=mp[][i+];
        mp[][]=tmp;
    }
}
void mvz(int d){
    if(d==){
        int tmp=mp[][];
        for(int i=;i<=;i++) mp[i][]=mp[i+][];
        mp[][]=tmp;
    }
    else if(d==){
        int tmp=mp[][];
        for(int i=;i<=;i++) mp[i][]=mp[i+][];
        mp[][]=tmp;
    }
    else if(d==){
        int tmp=mp[][];
        for(int i=;i>=;i--) mp[i][]=mp[i-][];
        mp[][]=tmp;
    }
    else{
        int tmp=mp[][];
        for(int i=;i>=;i--) mp[i][]=mp[i-][];
        mp[][]=tmp;
    }
}
bool cmp(){
    for(int i=;i<=dp;i++){
        if(sta[i]<ans[i]) return true;
        if(sta[i]>ans[i]) return false;
    }
    return false;
}
void dfs(int now,int las){
    if(che()>dp-now+) return;
    if(now==dp+){
        if(che()==){
            if(!fl){
                memcpy(ans,sta,sizeof sta);
                num=fin();
            }
            else if(cmp()){
                memcpy(ans,sta,sizeof sta);
                num=fin();
            }
            fl=true;
        }
        return;
    }
    for(int i=;i<=;i++){
        if(i==fan[las]) continue;
        if((i-)%>) mvh(i);
        else mvz(i);
        sta[++top]=i-+'A';
        dfs(now+,i);
        sta[top--]=' ';
        if((fan[i]-)%>) mvh(fan[i]);
        else mvz(fan[i]);
    }
}
void clear(){
    dp=;
    fl=false;
}
int main(){
    while(){
        clear();
        scanf("%d",&st[][]);
        //cout<<"aa "<<endl;
        if(st[][]==) break;
        scanf("%d",&st[][]);
        scanf("%d%d",&st[][],&st[][]);
        for(int i=;i<=;i++) scanf("%d",&st[][i]);
        scanf("%d%d",&st[][],&st[][]);
        for(int i=;i<=;i++) scanf("%d",&st[][i]);
        scanf("%d%d",&st[][],&st[][]);
        scanf("%d%d",&st[][],&st[][]);
        memcpy(mp,st,sizeof st);
        if(che()==){
            printf("No moves needed\n");
            printf("%d\n",fin());
            continue;
        }
        fl=false;
        while(!fl){
            dp++;
            memcpy(mp,st,sizeof st);
            dfs(,);
        }
        printf("%s\n",ans+);
        printf("%d\n",num);
    }
    return ;
}

骑士精神

也许可以折半爆搜。

但是显然不够漂亮。

明显“超15步-1”，就迭代加深了。

估价函数：每次，骑士最多归位一个。如果算上最后一步的空格，可能归位2个。

所以，当前和终止的差距-1大于剩余步数的话，一定不行。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=;
int T;
char st[][];
int dp;
bool fl;
int nd[][]={
    {,,,,,},
    {,,,,,},
    {,,,,,},
    {,,,,,},
    {,,,,,},
    {,,,,,}
};
int mp[][];
int mv[][]={{-,+},{-,-},{-,+},{-,-},{+,+},{+,-},{+,-},{+,+}};
int che(int re){
    int dif=;
    for(int i=;i<=;i++){
        for(int j=;j<=;j++){
            dif+=(mp[i][j]!=nd[i][j]);
        }
    }
    if(dif==) return ;
    return dp-re+>=dif-;
}
void dfs(int now,int x,int y){
    if(!che(now)) return;
    if(fl) return;
    if(now==dp+){
        if(che(now)==) {
            fl=true;return;
        }
    }
    for(int i=;i<;i++){
        int dx=x+mv[i][],dy=y+mv[i][];
        if(dx<||dx>) continue;
        if(dy<||dy>) continue;
        swap(mp[x][y],mp[dx][dy]);
        dfs(now+,dx,dy);
        swap(mp[x][y],mp[dx][dy]);
    }
}
void clear(){
    fl=false;dp=;
}
int main(){
    scanf("%d",&T);
    while(T--){
        clear();
        int sx,sy;
        for(int i=;i<=;i++){
            scanf("%s",st[i]+);
            for(int j=;j<=;j++){
                if(isdigit(st[i][j]))mp[i][j]=st[i][j]-'';
                else {
                    mp[i][j]=;sx=i,sy=j;
                }
            }
        }
        fl=false;
        for(dp=;dp<=;dp++){
            dfs(,sx,sy);
            if(fl) break;
        }
        if(fl) printf("%d\n",dp);
        else printf("-1\n");
    }
    return ;
}