Advertisement
Guest User

Untitled

a guest
Mar 30th, 2015
184
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 9.20 KB | None | 0 0
  1. #include <iostream>
  2. #include <cstdio>
  3. #include <map>
  4. #include <fstream>
  5. #include <queue>
  6. #include "CTcpFwd.h"
  7. using namespace std;
  8.  
  9. CTcpFwd Sock("maze","test.natodia.net",10000);
  10.  
  11. char buffer[4096];
  12.  
  13. pair <int,int> poz;
  14. map <pair <int,int> , int> mapa;
  15.  
  16. pair <int,int> v;
  17. pair <int,int> u;
  18. pair <int,int> wyj;
  19. map <pair <int,int> , int> odle;
  20. queue <pair <int,int> > bfs;
  21.  
  22. int n;
  23. int x, y;
  24.  
  25. int odl, m;
  26.  
  27. ifstream ifs;
  28. ofstream ofs;
  29.  
  30. void wypisz()
  31. {
  32.     Sock.SwitchStdout("DefaultStdout");
  33.     for (int i=-25; i<=25; i++)
  34.     {
  35.         for (int j=-50; j<=50; j++)
  36.         {
  37.             if (!i && !j)
  38.             {
  39.                 printf("O");
  40.                 continue;
  41.             }
  42.             if (!mapa[make_pair(poz.first+i, poz.second+j)])
  43.             {
  44.                 printf("*");
  45.                 continue;
  46.             }
  47.             if (mapa[make_pair(poz.first+i, poz.second+j)]==1)
  48.             {
  49.                 printf(".");
  50.                 continue;
  51.             }
  52.             if (mapa[make_pair(poz.first+i, poz.second+j)]==-1)
  53.             {
  54.                 printf("X");
  55.                 continue;
  56.             }
  57.             if (mapa[make_pair(poz.first+i, poz.second+j)]==2)
  58.             {
  59.                 printf("E");
  60.                 continue;
  61.             }
  62.         }
  63.         printf("\n");
  64.     }
  65.     printf("\n");
  66.     Sock.SwitchStdout("maze");
  67.     printf("TURNS_LEFT\n");
  68.     scanf("%s", buffer);
  69.     scanf("%d", &n);
  70.     Sock.SwitchStdout("DefaultStdout");
  71.     printf("%d\n", n);
  72.     Sock.SwitchStdout("maze");
  73. }
  74.  
  75. void czytaj()
  76. {
  77.     printf("SCAN\n");
  78.     scanf("%s", buffer);
  79.     scanf("%d", &n);
  80.     for (int i=1; i<=n; i++)
  81.     {
  82.         scanf("%s", buffer);
  83.         scanf("%d%d", &x, &y);
  84.         if (buffer[0]=='W')
  85.         {
  86.             mapa[make_pair(poz.first+x, poz.second+y)]=-1;
  87.             continue;
  88.         }
  89.         if (buffer[0]=='E')
  90.         {
  91.             mapa[make_pair(poz.first+x, poz.second+y)]=2;
  92.             continue;
  93.         }
  94.         mapa[make_pair(poz.first+x, poz.second+y)]=1;
  95.     }
  96. }
  97.  
  98. int czekaj()
  99. {
  100.     //wypisz();
  101.     /*Sock.SwitchStdout("DefaultStdout");
  102.     for (int i=1; i<=40; i++)
  103.     printf("\n");
  104.     Sock.SwitchStdout("maze");*/
  105.     printf("WAIT\n");
  106.     scanf("%s", buffer);
  107.     scanf("%s", buffer);
  108.     //wypisz();
  109.     printf("TURNS_LEFT\n");
  110.     scanf("%s", buffer);
  111.     scanf("%d", &m);
  112.     if (m>odl)
  113.     {
  114.         odl=m;
  115.         return 1;
  116.     }
  117.     /*Sock.SwitchStdout("DefaultStdout");
  118.     printf("%d\n", n);
  119.     Sock.SwitchStdout("maze");*/
  120.     odl=m;
  121.     return 0;
  122. }
  123.  
  124. void czekajnakoniec()
  125. {
  126.     int odl=1000000;
  127.     while(1)
  128.     {
  129.         if(czekaj())
  130.         break;
  131.         Sock.SwitchStdout("DefaultStdout");
  132.         printf("%d\n", m);
  133.         Sock.SwitchStdout("maze");
  134.     }
  135. }
  136.  
  137. void szukajr()
  138. {
  139.     usleep(200000);
  140.     buffer[0]='.';
  141.     ifs.open("in.in");
  142.     ifs >> buffer;
  143.     ifs.close();
  144.     ofs.open("in.in");
  145.     ofs << ".";
  146.     ofs.close();
  147. }
  148.  
  149. void szukaja()
  150. {
  151.     odle.clear();
  152.     odle[poz]=1;
  153.     bfs.push(poz);
  154.     while(!bfs.empty())
  155.     {
  156.         v=bfs.front();
  157.         bfs.pop();
  158.         if (!mapa[v])
  159.         continue;
  160.         /*Sock.SwitchStdout("DefaultStdout");
  161.         printf("%d %d   %d\n", v.first, v.second, odle[v]);
  162.         Sock.SwitchStdout("maze");*/
  163.         u=v;
  164.         u.first++;
  165.         if (mapa[u]>=0 && !odle[u])
  166.         {
  167.             odle[u]=odle[v]+1;
  168.             bfs.push(u);
  169.         }
  170.  
  171.         u=v;
  172.         u.first--;
  173.         if (mapa[u]>=0 && !odle[u])
  174.         {
  175.             odle[u]=odle[v]+1;
  176.             bfs.push(u);
  177.         }
  178.  
  179.         u=v;
  180.         u.second++;
  181.         if (mapa[u]>=0 && !odle[u])
  182.         {
  183.             odle[u]=odle[v]+1;
  184.             bfs.push(u);
  185.         }
  186.  
  187.         u=v;
  188.         u.second--;
  189.         if (mapa[u]>=0 && !odle[u])
  190.         {
  191.             odle[u]=odle[v]+1;
  192.             bfs.push(u);
  193.         }
  194.     }
  195.     v=poz;
  196.     wyj=poz;
  197.     for (map <pair <int,int> , int>::iterator it=odle.begin(); it!=odle.end(); it++)
  198.     {
  199.         if (!mapa[it->first] && (v==poz || (it->second)<odle[v]))
  200.         {
  201.             v=(it->first);
  202.         }
  203.         if (mapa[it->first]==2)
  204.         {
  205.             wyj=(it->first);
  206.         }
  207.     }
  208.     /*Sock.SwitchStdout("DefaultStdout");
  209.     printf("  %d %d    %d\n", v.first, v.second, odle[v]);
  210.     Sock.SwitchStdout("maze");*/
  211.     if (wyj!=poz)
  212.     v=wyj;
  213.     while(odle[v]>2)
  214.     {
  215.         /*Sock.SwitchStdout("DefaultStdout");
  216.         printf("%d %d    %d\n", v.first, v.second, odle[v]);
  217.         Sock.SwitchStdout("maze");*/
  218.         u=v;
  219.         u.first++;
  220.         if (odle[u]+1==odle[v])
  221.         {
  222.             v=u;
  223.             continue;
  224.         }
  225.  
  226.         u=v;
  227.         u.first--;
  228.         if (odle[u]+1==odle[v])
  229.         {
  230.             v=u;
  231.             continue;
  232.         }
  233.  
  234.         u=v;
  235.         u.second++;
  236.         if (odle[u]+1==odle[v])
  237.         {
  238.             v=u;
  239.             continue;
  240.         }
  241.  
  242.         u=v;
  243.         u.second--;
  244.         if (odle[u]+1==odle[v])
  245.         {
  246.             v=u;
  247.             continue;
  248.         }
  249.     }
  250.     /*Sock.SwitchStdout("DefaultStdout");
  251.     printf("    %d %d    %d\n", poz.first, poz.second, odle[v]);
  252.     Sock.SwitchStdout("maze");
  253.     Sock.SwitchStdout("DefaultStdout");
  254.     printf("    %d %d    %d\n", v.first, v.second, odle[v]);
  255.     Sock.SwitchStdout("maze");*/
  256.     if (v.first==poz.first-1)
  257.     {
  258.         buffer[0]='w';
  259.         return;
  260.     }
  261.     if (v.first==poz.first+1)
  262.     {
  263.         buffer[0]='s';
  264.         return;
  265.     }
  266.     if (v.second==poz.second-1)
  267.     {
  268.         buffer[0]='a';
  269.         return;
  270.     }
  271.     if (v.second==poz.second+1)
  272.     {
  273.         buffer[0]='d';
  274.         return;
  275.     }
  276. }
  277.  
  278. int dawajruch()
  279. {
  280.     //szukajr();
  281.     szukaja();
  282.     /*Sock.SwitchStdout("DefaultStdout");
  283.     printf("\n");
  284.     Sock.SwitchStdout("maze");*/
  285.     //system("pause");
  286.     if (buffer[0]=='.')
  287.     return 0;
  288.     /*Sock.SwitchStdin("DefaultStdin");
  289.     scanf("%s", buffer);
  290.     Sock.SwitchStdin("maze");*/
  291.     if (buffer[0]=='w')
  292.     {
  293.         printf("MOVE -1 0\n");
  294.         scanf("%s", buffer);
  295.         if (buffer[0]=='O')
  296.         {
  297.             poz.first--;
  298.             //Sock.SwitchStdout("DefaultStdout");
  299.             //printf("poszlo\n");
  300.             //Sock.SwitchStdout("maze");
  301.             return 1;
  302.         }
  303.         scanf("%s", buffer);
  304.         scanf("%s", buffer);
  305.         scanf("%s", buffer);
  306.         mapa[make_pair(poz.first-1, poz.second)]=-1;
  307.         return 0;
  308.     }
  309.     if (buffer[0]=='s')
  310.     {
  311.         printf("MOVE 1 0\n");
  312.         scanf("%s", buffer);
  313.         if (buffer[0]=='O')
  314.         {
  315.             poz.first++;
  316.             //Sock.SwitchStdout("DefaultStdout");
  317.             //printf("poszlo\n");
  318.             //Sock.SwitchStdout("maze");
  319.             return 1;
  320.         }
  321.         scanf("%s", buffer);
  322.         scanf("%s", buffer);
  323.         scanf("%s", buffer);
  324.         mapa[make_pair(poz.first+1, poz.second)]=-1;
  325.         return 0;
  326.     }
  327.     Sock.SwitchStdin("maze");
  328.     if (buffer[0]=='a')
  329.     {
  330.         printf("MOVE 0 -1\n");
  331.         scanf("%s", buffer);
  332.         if (buffer[0]=='O')
  333.         {
  334.             poz.second--;
  335.             //Sock.SwitchStdout("DefaultStdout");
  336.             //printf("poszlo\n");
  337.             //Sock.SwitchStdout("maze");
  338.             return 1;
  339.         }
  340.         scanf("%s", buffer);
  341.         scanf("%s", buffer);
  342.         scanf("%s", buffer);
  343.         mapa[make_pair(poz.first, poz.second-1)]=-1;
  344.         return 0;
  345.     }
  346.     if (buffer[0]=='d')
  347.     {
  348.         printf("MOVE 0 1\n");
  349.         scanf("%s", buffer);
  350.         if (buffer[0]=='O')
  351.         {
  352.             poz.second++;
  353.             //Sock.SwitchStdout("DefaultStdout");
  354.             //printf("poszlo\n");
  355.             //Sock.SwitchStdout("maze");
  356.             return 1;
  357.         }
  358.         scanf("%s", buffer);
  359.         scanf("%s", buffer);
  360.         scanf("%s", buffer);
  361.         mapa[make_pair(poz.first, poz.second+1)]=-1;
  362.         return 0;
  363.     }
  364.     return 0;
  365. }
  366.  
  367. int main()
  368. {
  369.     Sock.SwitchStdout("maze");
  370.     Sock.SwitchStdin("maze");
  371.     scanf("%s", buffer);
  372.     Sock.SwitchStdout("DefaultStdout");
  373.     printf("%s\n", buffer);
  374.     Sock.SwitchStdout("maze");
  375.  
  376.     Sock.SwitchStdin("DefaultStdin");
  377.     scanf("%s", buffer);
  378.     Sock.SwitchStdin("maze");
  379.     printf("%s\n", buffer);
  380.  
  381.     scanf("%s", buffer);
  382.     Sock.SwitchStdout("DefaultStdout");
  383.     printf("%s\n", buffer);
  384.     Sock.SwitchStdout("maze");
  385.  
  386.     Sock.SwitchStdin("DefaultStdin");
  387.     scanf("%s", buffer);
  388.     Sock.SwitchStdin("maze");
  389.     printf("%s\n", buffer);
  390.  
  391.     scanf("%s", buffer);
  392.     Sock.SwitchStdout("DefaultStdout");
  393.     printf("%s\n", buffer);
  394.     Sock.SwitchStdout("maze");
  395.     while(1)
  396.     {
  397.         //Sock.SwitchStdout("DefaultStdout");
  398.         //printf("od nowa\n\n");
  399.         //Sock.SwitchStdout("maze");
  400.         poz=make_pair(0,0);
  401.         mapa.clear();
  402.         czytaj();
  403.         mapa[poz]=1;
  404.         while(mapa[poz]!=2)
  405.         {
  406.             mapa[poz]=1;
  407.             czytaj();
  408.             wypisz();
  409.             if(dawajruch())
  410.             if(czekaj())
  411.             break;
  412.         }
  413.         if (mapa[poz]==2)
  414.         czekajnakoniec();
  415.     }
  416.     return 0;
  417. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement