“国家队爷”杯液体战争AI比赛!!__SymenYang

原帖

　　这两天一直在搞这个AI，提供的样例更本不是我的风格啊，看不懂更不会改。。。

　　所以我自己写了一个AI的平台，现在在不断的修改AI的策略，smart样例还是很容易过的，让line的行走速度变慢一点到每回合15一下就可以了。这里大概写一下自己写了这么久，看了这么多别人的比赛的想法。

　　首先进攻分两种，一种是集群的进攻，一种是离散的进攻。集群进攻容易被拦截，但是攻击力充足（ps：规则允许多个水滴在同一个地方），离散进攻（如smart的两边）则攻击力相对较弱，但是不容易被拦截。line的进攻属于集群性进攻，有一些逗比的AI非常有效就是将中路一分为二从稍微靠上一点和稍微靠下一点走，然后就赢了。。。。防守一般是集群防守，因为张开的话火力不足而且比较慢。对付smart那种可以，但是对付line就挂了。。集群防守一般集中于大脑周围，但是也会有漏洞（水滴太少），所以应该加一个流动的机制，一旦有脑内未被打的敌方水滴，就过去打一下。这个写着有点麻烦。。。然后离散进攻的时候可以选择走没有人打得到的地方，然后就非常的慢，还要在优化一下。。。感觉以后要写得更高级恐怕KD树是不得不写了。。。

　　说一下我的AI平台，node代表水滴，水滴的命令有许多种，不详细介绍（看注释），大体流程是，读入-->下命令-->执行。有点像三国志9的模式。。。所有存活水滴用两个链表来存，代码如下（SymenAIalpha2）

　　

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;

struct position
{
    int x;
    int y;

    position(int a=0,int b=0)
    {
        x=a;y=b;
    }

    bool outofrange()
    {
        return (x>10000)||(x<=0)||y>10000||y<=0;
    }
};

struct node
{
    int number;
    int level;
    position pos;
    position Gototar;//集合地
    int tarnum;//攻击目标，-1，向Gototar移动,自由攻击
    int blood;

    int followNum;//和几号计划一样，虚拟计划，不是实体。0 == 没有计划

    bool alive;
    int movetype;
    node* next;
    node* last;

    node(int a=0,position tar=position(9000,5000),int bl=20)
    {
        movetype=1;
        alive=true;
        number=a;
        level=0;
        Gototar=tar;
        blood=bl;
        tarnum=-1;
        next=last=NULL;
        followNum=0;
    }
};

node plan[1000];
int plancnt=1;
node blue[325000];
node red[325000];
int nextred[325000];
int nextblue[325000];
int cntred=-1;
int cntblue=-1;
int BBB=5000;
int RBB=5000;
double getdis(node a,node b) {return sqrt((a.pos.x-b.pos.x)*(a.pos.x-b.pos.x)+(a.pos.y-b.pos.y)*(a.pos.y-b.pos.y));}
double getdis(node a,position b) {return sqrt((a.pos.x-b.x)*(a.pos.x-b.x)+(a.pos.y-b.y)*(a.pos.y-b.y));}
double getdis(position a,position b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}

bool inrand(node a,node b,int dis=30)
{
    int far=dis+a.level*3;
    double ds=getdis(a,b);
    if (ds<=far)
        return true;
    return false;
}
bool inrand(node a,position b,int dis=30)
{
    int far=dis+a.level*3;
    double ds=getdis(a,b);
    if (ds<=far)
        return true;
    return false;
}

int defcnt=0;

node* redl;
node* bluel;

node* Add(node* a,node* root)
{
    if (!a->next)
    {
        a->next=root;
        if (a->next)
            a->next->last=a;
        return a;
    }
    return NULL;
}

bool Dlt(node* now)
{
    if (now->next)
    {
        if (now->last)
        {
            now->last->next=now->next;
            now->next->last=now->last;
        }
        else
        {
            now->next->last=now->last;
        }
        return true;
    }
    else
    {
        if (now->last)
        {
            now->last->next=NULL;
            return true;
        }
        else
        {
            return false;
        }
    }
}

node* Clean(node* root)
{
    for (node* now=root;now;now=now->next)
    {
        if (!now->alive)
        {
            if (now==root)
                root=now->next;
            Dlt(now);
        }
    }
    return root;
}

position GetNextStep(node a,node b,int dis=30)
{
    double ds=getdis(a,b);
    if (ds<=dis) return b.pos;
    int dx=b.pos.x-a.pos.x;
    int dy=b.pos.y-a.pos.y;
    return position(a.pos.x+dx*(dis/ds),a.pos.y+dy*(dis/ds));
}
int biao1[4]={-1,-1,1,1};
int biao2[4]={-1,1,-1,1};
int AvoidEps=400;
position GetNextStep2(node a,int b,int dis=30)
{
    int type=plan[b].movetype;
    if (type==1)
    {
        double ds=getdis(a,plan[b].Gototar);
        if (ds<=dis) return plan[b].Gototar;
        int dx=plan[b].Gototar.x-a.pos.x;
        int dy=plan[b].Gototar.y-a.pos.y;
        position ret=position(a.pos.x+dx*(dis/ds),a.pos.y+dy*(dis/ds));
        if (getdis(a,ret)>dis) ret.x--;
        return ret;
    }
    if (type==2)
    {
        double ds=getdis(a,plan[b].Gototar);
//        if (ds<=dis) return plan[b].Gototar;
        int dx=plan[b].Gototar.x-a.pos.x;
        int dy=plan[b].Gototar.y-a.pos.y;
        int maxd=0x3f3f3f3f;
        double minds=10101010101010.0;
        position ret(0,0);
        for (int i=-dis;i<=dis;++i)
        {
            for (int j=-dis;j<=dis;++j)
            {
                if (i*i+j*j>dis*dis) continue;
                if (position(a.pos.x+i,a.pos.y+j).outofrange()) continue;
                int sum=0;
                for (node* now=bluel;now;now=now->next)
                {
                    if (inrand(*now,position(a.pos.x+i,a.pos.y+j),AvoidEps)) sum++;
                }
                if (sum==maxd)
                {
                    double ds2=getdis(plan[b].Gototar,position(a.pos.x+i,a.pos.y+j));
                    if (ds2<minds)
                    {
                        minds=ds2;
                        ret=position(a.pos.x+i,a.pos.y+j);
                    }
                }
                if (sum<maxd)
                {
                    maxd=sum;
                    ret=position(a.pos.x+i,a.pos.y+j);
                }
            }
        }
        return ret;
    }
}

//#define Debug
position GetNextStep(node a,int dis=30)
{
    int type=a.movetype;
    if (type==1)
    {
        double ds=getdis(a,a.Gototar);
        if (ds<=dis) return a.Gototar;
        int dx=a.Gototar.x-a.pos.x;
        int dy=a.Gototar.y-a.pos.y;
        position ret=position(a.pos.x+dx*(dis/ds),a.pos.y+dy*(dis/ds));
        if (getdis(a,ret)>dis) ret.x--;
        if (getdis(a,ret)>dis) ret.y--;
        return ret;
    }
    if (type==2)
    {
        double ds=getdis(a,a.Gototar);
        if (ds<=dis) return a.Gototar;
        int maxd=0x3f3f3f3f;
        double minds=12356434543.45;
        position ret(0,0);
        for (int i=-dis;i<=dis;++i)
        {
            for (int j=-dis;j<=dis;++j)
            {
                if (i*i+j*j>dis*dis) continue;
                if (position(a.pos.x+i,a.pos.y+j).outofrange()) continue;
                int sum=0;
                for (node* now=bluel;now;now=now->next)
                {
                    if (inrand(*now,position(a.pos.x+i,a.pos.y+j),AvoidEps)) 
                        sum++;
                }
                if (sum==maxd)
                {
                    double ds2=getdis(a.Gototar,position(a.pos.x+i,a.pos.y+j));
                    if (ds2<minds)
                    {
                        minds=ds2;
                        ret=position(a.pos.x+i,a.pos.y+j);
                    }
                }
                if (sum<maxd)
                {
                    maxd=sum;
                    ret=position(a.pos.x+i,a.pos.y+j);
                }
            }
        }
        return ret;
    }
}

int RandomShoot(node a,int k=1)
{
    int ret=-1;
    double mindis=12334444444.0;
    for (node* now=bluel;now;now=now->next)
    {
        if (inrand(a,*now)&&now->alive)
        {
            if (k==0)
                return now->number;
            if (k==1)
            {
                double ds=getdis(a,*now);
                if (ds<mindis)
                {
                    mindis=ds;
                    ret=now->number;
                }
            }
            if (k==2)
            {
                if (now->pos.x<mindis)
                {
                    mindis=now->pos.x;
                    ret=now->number;
                }
            }
        }
    }
    return ret;
}

int sho[360000];
int ta[360000];
int nowbunum=0;
void Doit()
{
    int atnum=0,monum=0;
//Att Turn
    for (node* now=redl;now;now=now->next)
    {
        if (now->followNum)
        {
            int k=now->followNum;
            if (plan[k].tarnum!=-1)
            {
                int tarnum=plan[k].tarnum;
                if (blue[tarnum].alive)
                {
                    now->level++;
                    atnum++;
                    sho[atnum]=now->number;
                    ta[atnum]=tarnum;
                    blue[tarnum].blood--;
                    if (blue[tarnum].blood==0) 
                    {
                        blue[tarnum].alive=false;
                        plan[k].tarnum=-1;
                    }
                }
            }
            else
            {
                int t=RandomShoot(*now);
                if (t!=-1)
                {    
                    now->level++;
                    atnum++;
                    sho[atnum]=now->number;
                    ta[atnum]=t;
                    blue[t].blood--;
                    if (blue[t].blood==0) blue[t].alive=false;
                }
            }
            continue;
        }
        if (now->tarnum!=-1)
        {
            int tarnum=now->tarnum;
            if (blue[tarnum].alive)
            {
                now->level++;
                atnum++;
                sho[atnum]=now->number;
                ta[atnum]=tarnum;
                blue[tarnum].blood--;
                if (blue[tarnum].blood==0) blue[tarnum].alive=false;
            }
            else
            {
                int t=RandomShoot(*now);
                if (t!=-1)
                {    
                    now->level++;
                    atnum++;
                    sho[atnum]=now->number;
                    ta[atnum]=t;
                    blue[t].blood--;
                    if (blue[t].blood==0) blue[t].alive=false;
                }
            }
        }
        else
        {
            int t=RandomShoot(*now);
            if (t!=-1)
            {    
                now->level++;
                atnum++;
                sho[atnum]=now->number;
                ta[atnum]=t;
                blue[t].blood--;
                if (blue[t].blood==0) blue[t].alive=false;
            }
        }
//End Att Turn
    }
//print
    {
        printf("%d
",atnum);
        for (int i=1;i<=atnum;++i)
        {
            printf("%d %d
",sho[i],ta[i]);
        }
    }
//End print
//MoveTurn
    for (node* now=redl;now;now=now->next)
    {
        if (!now->followNum)
        {
            if (now->pos.x==now->Gototar.x&&now->pos.y==now->Gototar.y) continue;
            monum++;
        }
        else
        {
            monum++;
        }
    }
//End MoveTurn
//Print    
    printf("%d
",monum);
    for (node* now=redl;now;now=now->next)
    {
        if (!now->followNum)
        {
            if (now->pos.x==now->Gototar.x&&now->pos.y==now->Gototar.y) continue;
            position p=GetNextStep(*now);
            now->pos=p;
            printf("%d %d %d
",now->number,p.x,p.y);
        }
        else
        {
            position p=GetNextStep2(*now,now->followNum);
            now->pos=p;
            printf("%d %d %d
",now->number,p.x,p.y);
        }
    }    
//End Print
//build
    printf("%d
",nowbunum);
    for (int i=1;i<=nowbunum;++i)
    {
        cntred++;
        red[cntred].pos=position(0,red[cntred].Gototar.y);
        redl=Add(&red[cntred],redl);
        printf("%d
",red[cntred].pos.y);
    }
    nowbunum=0;
//End build
}


void init()
{
    int ns;
    scanf("%d",&ns);
    for (int i=1;i<=ns;++i)
    {
        int sho,tar;
        scanf("%d%d",&sho,&tar);
        blue[sho].level++;
        red[tar].blood--;
        if (red[tar].blood==0)
        {
            red[tar].alive=false;
        }
    }
    int nm;
    scanf("%d",&nm);
    for (int i=1;i<=nm;++i)
    {
        int mover,xx,yy;
        scanf("%d%d%d",&mover,&xx,&yy);
        blue[mover].pos=position(xx,yy);
    }
    int nn;
    scanf("%d",&nn);
    for (int i=1;i<=nn;++i)
    {
        ++cntblue;
        int y;
        scanf("%d",&y);
        blue[cntblue].pos=position(10000,y);
        bluel=Add(&blue[cntblue],bluel);
    }
    scanf("%d%d%d%d",&ns,&ns,&ns,&ns);
}

int _round=-1;

void AI()
{
    ++_round;
    if (_round%5==0) nowbunum++;        
    if (red[0].alive&&red[0].pos.x==9000)
    {
        red[0].Gototar=position(9000,5500);
    }
    if (plan[1].Gototar.x<=9000)
    plan[1].Gototar.x+=13;
}

void PreMeet()
{
    for (int i=1;i<325000;++i)
    {
        red[i].Gototar=position(1750,5000);
        red[i].followNum=1;
        blue[i].number=red[i].number=i;
    }
    plan[1].Gototar=position(1750,5000);
    red[0].Gototar=position(9000,7999);
    red[0].movetype=2;
    cerr<<"Init Successfully"<<endl;
}

int main()
{
#ifdef Debug
    freopen("blue.in","r",stdin);
#endif
    PreMeet();
    while(true)
    {
        init();
        Clean(redl);
        Clean(bluel);
        cerr<<"Read Successfully"<<endl;
        AI();
        cerr<<"AI Successfully"<<endl;
        Doit();
        Clean(redl);
        Clean(bluel);
        cerr<<"Do Successfully"<<endl;
    }
    return 0;
}