“国家队爷”杯液体战争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=,int b=)
     {
         x=a;y=b;
     }

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

 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=,position tar=position(,),int bl=)
     {
         movetype=;
         alive=true;
         number=a;
         level=;
         Gototar=tar;
         blood=bl;
         tarnum=-;
         next=last=NULL;
         followNum=;
     }
 };

 node plan[];
 int plancnt=;
 node blue[];
 node red[];
 int nextred[];
 int nextblue[];
 int cntred=-;
 int cntblue=-;
 int BBB=;
 int RBB=;
 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=)
 {
     int far=dis+a.level*;
     double ds=getdis(a,b);
     if (ds<=far)
         return true;
     return false;
 }
 bool inrand(node a,position b,int dis=)
 {
     int far=dis+a.level*;
     double ds=getdis(a,b);
     if (ds<=far)
         return true;
     return false;
 }

 int defcnt=;

 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=)
 {
     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[]={-,-,,};
 int biao2[]={-,,-,};
 int AvoidEps=;
 position GetNextStep2(node a,int b,int dis=)
 {
     int type=plan[b].movetype;
     if (type==)
     {
         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==)
     {
         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(,);
         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=;
                 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=)
 {
     int type=a.movetype;
     if (type==)
     {
         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==)
     {
         double ds=getdis(a,a.Gototar);
         if (ds<=dis) return a.Gototar;
         int maxd=0x3f3f3f3f;
         double minds=12356434543.45;
         position ret(,);
         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=;
                 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=)
 {
     int ret=-;
     double mindis=12334444444.0;
     for (node* now=bluel;now;now=now->next)
     {
         if (inrand(a,*now)&&now->alive)
         {
             if (k==)
                 return now->number;
             if (k==)
             {
                 double ds=getdis(a,*now);
                 if (ds<mindis)
                 {
                     mindis=ds;
                     ret=now->number;
                 }
             }
             if (k==)
             {
                 if (now->pos.x<mindis)
                 {
                     mindis=now->pos.x;
                     ret=now->number;
                 }
             }
         }
     }
     return ret;
 }

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

 void init()
 {
     int ns;
     scanf("%d",&ns);
     for (int i=;i<=ns;++i)
     {
         int sho,tar;
         scanf("%d%d",&sho,&tar);
         blue[sho].level++;
         red[tar].blood--;
         if (red[tar].blood==)
         {
             red[tar].alive=false;
         }
     }
     int nm;
     scanf("%d",&nm);
     for (int i=;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=;i<=nn;++i)
     {
         ++cntblue;
         int y;
         scanf("%d",&y);
         blue[cntblue].pos=position(,y);
         bluel=Add(&blue[cntblue],bluel);
     }
     scanf("%d%d%d%d",&ns,&ns,&ns,&ns);
 }

 int _round=-;

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

 void PreMeet()
 {
     for (int i=;i<;++i)
     {
         red[i].Gototar=position(,);
         red[i].followNum=;
         blue[i].number=red[i].number=i;
     }
     plan[].Gototar=position(,);
     red[].Gototar=position(,);
     red[].movetype=;
     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 ;
 }