UVa 10196 - Check The Check （模拟）

最新推荐文章于 2020-09-01 16:50:09 发布
最新推荐文章于 2020-09-01 16:50:09 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： 模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cc_again/article/details/8270016
版权

题目链接：

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1137

 

题目大意：

给你一副国际象棋的格局，让你判断哪方被将军了。

 

解题思路：

模拟题，考虑每方每一颗棋子的对另一方的攻击范围，如果对方王在某一颗棋子的攻击范围内，则对方被将军了。

注意只有马能越过棋子，其余棋子不能越过棋子，如果挡住了，则攻击范围在这个方向上终止。

 

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#define eps 1e-6
#define INF (1<<20)
#define PI acos(-1.0)
using namespace std;


bool judge(int x,int y)  //判断坐标是否越界
{
    if(x>=1&&x<=8&&y>=1&&y<=8)
        return true;
    return false;
}
int main()
{
    char mmap[100][100];
    int black[70][5],white[70][5],numb=0,numw=0;//numb,numw分别代表黑棋和白棋的数量
    int bk,wk,ca=0,flag=0;  //bk,wk分别代表黑王和白王的位置
    
    do
    {
        //if(flag==1) //空行的读取
          //  getline(cin,temp);
        numb=numw=flag=0;  //注意清零runtime error 了好多次

        for(int i=1;i<=8;i++)
        {
            for(int j=1;j<=8;j++)
            {
                 scanf("%c",&mmap[i][j]);
                 if(mmap[i][j]!='.')
                 {

                     flag=1;
                     if(mmap[i][j]>='a'&&mmap[i][j]<='z')
                     {
                         numb++;
                         black[numb][1]=i;
                         black[numb][2]=j;
                         if(mmap[i][j]=='k')
                            bk=numb;

                     }
                     else
                     {
                         numw++;
                         white[numw][1]=i;
                         white[numw][2]=j;
                         if(mmap[i][j]=='K')
                            wk=numw;
                     }
                 }

            }
            getchar();//读入每一行的回车
        }
        getchar();//读入每一组的空行
        //printf("flag:%d\n",flag);
        int winb=0;
        for(int i=1;i<=numb;i++)
        {
            int can1=0,can2=0;
            int can3=0,can4=0;
            if(i==bk)
                continue;
            int x=black[i][1],y=black[i][2];
            switch(mmap[x][y])  
            {
                //如果是卒的话
                case 'p':if((judge(x+1,y-1)&&mmap[x+1][y-1]=='K')||(judge(x+1,y+1)&&mmap[x+1][y+1]=='K'))
                         {
                             winb=1;
                             break;
                         }
                         break;
                //如果是马的话
                case 'n':if((judge(x-1,y+2)&&mmap[x-1][y+2]=='K')||(judge(x+1,y+2)&&mmap[x+1][y+2]=='K'))
                         {
                             winb=1;
                             break;
                         }
                         if((judge(x-2,y+1)&&mmap[x-2][y+1]=='K')||(judge(x+2,y+1)&&mmap[x+2][y+1]=='K'))
                         {
                             winb=1;
                             break;
                         }
                         if((judge(x-2,y-1)&&mmap[x-2][y-1]=='K')||(judge(x+2,y-1)&&mmap[x+2][y-1]=='K'))
                         {
                             winb=1;
                             break;
                         }
                         if((judge(x-1,y-2)&&mmap[x-1][y-2]=='K')||(judge(x+1,y-2)&&mmap[x+1][y-2]=='K'))
                         {
                             winb=1;
                             break;
                         }
                         break;  //注意要跳出来，不然如果不满足的话，继续执行下一个case

                case 'b':   //如果是象的话

                        for(int i=1;i<=8-x;i++)
                         {
                             if(judge(x+i,y+i))
                             {
                                 if(mmap[x+i][y+i]=='K')
                                 {
                                    if(can1==0)
                                    {
                                       winb=1;
                                        break;
                                    }
                                 }
                                else if(mmap[x+i][y+i]!='.')
                                {
                                    can1=1;
                                }
                             }
                             if(judge(x+i,y-i))
                             {
                                 if(mmap[x+i][y-i]=='K')
                                 {
                                     if(can2==0)
                                     {
                                         winb=1;
                                         break;
                                     }

                                 }
                                 else if(mmap[x+i][y-i]!='.')
                                          can2=1;

                             }
                         }
                         if(winb==1)
                            break;


                         for(int i=1;i<=x-1;i++)
                         {
                             if(judge(x-i,y+i))
                             {
                                 if(mmap[x-i][y+i]=='K')
                                 {
                                    if(can3==0)
                                    {
                                        winb=1;
                                        break;

                                    }
                                 }
                                 else if(mmap[x-i][y+i]!='.')
                                 {
                                     can3=1;
                                 }

                             }
                             if(judge(x-i,y-i))
                             {
                                 if(mmap[x-i][y-i]=='K')
                                 {
                                     if(can4==0)
                                     {
                                          winb=1;
                                          break;
                                     }
                                 }
                                 else if(mmap[x-i][y-i]!='.')
                                 {
                                     can4=1;
                                 }

                             }

                         }
                         if(winb==1)
                            break;
                         break;
                //如果是车的话
                case 'r':for(int i=1;i<=x-1;i++) //向上
                            {
                               /* if(judge(x-i,y)==false)
                                    continue;*/

                                if(mmap[x-i][y]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x-i][y]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            for(int i=1;i<=8-x;i++) //向下
                            {
                                /*if(judge(x+i,y)==false)
                                    continue;*/

                                if(mmap[x+i][y]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x+i][y]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            for(int j=1;j<=y-1;j++) //向左
                            {
                              /*  if(judge(x,y-j)==false)
                                    continue;*/
                                if(mmap[x][y-j]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x][y-j]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            for(int j=1;j<=8-y;j++)//向右
                            {
                               /* if(judge(x,y+j)==false)
                                    continue;*/
                                if(mmap[x][y+j]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x][y+j]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            break;
                    
                //如果是后的话
                case 'q':
                        for(int i=1;i<=8-x;i++)
                         {
                             if(judge(x+i,y+i))
                             {
                                 if(mmap[x+i][y+i]=='K')
                                 {
                                    if(can1==0)
                                    {
                                       winb=1;
                                        break;
                                    }
                                 }
                                else if(mmap[x+i][y+i]!='.')
                                {
                                    can1=1;
                                }
                             }
                             if(judge(x+i,y-i))
                             {
                                 if(mmap[x+i][y-i]=='K')
                                 {
                                     if(can2==0)
                                     {
                                         winb=1;
                                         break;
                                     }

                                 }
                                 else if(mmap[x+i][y-i]!='.')
                                          can2=1;

                             }
                         }
                         if(winb==1)
                            break;

                         for(int i=1;i<=x-1;i++)
                         {
                             if(judge(x-i,y+i))
                             {
                                 if(mmap[x-i][y+i]=='K')
                                 {
                                    if(can3==0)
                                    {
                                        winb=1;
                                        break;

                                    }
                                 }
                                 else if(mmap[x-i][y+i]!='.')
                                 {
                                     can3=1;
                                 }

                             }
                             if(judge(x-i,y-i))
                             {
                                 if(mmap[x-i][y-i]=='K')
                                 {
                                     if(can4==0)
                                     {
                                          winb=1;
                                          break;
                                     }
                                 }
                                 else if(mmap[x-i][y-i]!='.')
                                 {
                                     can4=1;
                                 }

                             }

                         }
                         if(winb==1)
                            break;

                         for(int i=1;i<=x-1;i++) //向上
                            {
                              /*  if(judge(x-i,y)==false)
                                    continue;*/
                                if(mmap[x-i][y]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x-i][y]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            for(int i=1;i<=8-x;i++) //向下
                            {
                                /*if(judge(x+i,y)==false)
                                    continue;*/
                                if(mmap[x+i][y]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x+i][y]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            for(int j=1;j<=y-1;j++) //向左
                            {
                               /* if(judge(x,y-j)==false)
                                    continue;*/
                                if(mmap[x][y-j]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x][y-j]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            for(int j=1;j<=8-y;j++)//向右
                            {
                                /*if(judge(x,y+j)==false)
                                    continue;*/
                                if(mmap[x][y+j]=='K')
                                {
                                    winb=1;
                                    break;
                                }
                                else if(mmap[x][y+j]!='.')
                                    break;
                            }
                            if(winb==1)
                                break;
                            break;

            }//switch
            if(winb==1)
                break;
        }
        if(winb==1)
        {
             printf("Game #%d: white king is in check.\n",++ca);
             continue;
        }
        int wina=0;
        for(int i=1;i<=numw;i++)
        {
            if(i==wk)
                continue;
            int can1=0,can2=0;
            int can3=0,can4=0;

            int x=white[i][1],y=white[i][2];
            switch(mmap[x][y])
            {
                case 'P':if((judge(x-1,y-1)&&mmap[x-1][y-1]=='k')||(judge(x-1,y+1)&&mmap[x-1][y+1]=='k'))
                         {
                             wina=1;
                             break;
                         }
                         break;
                case 'N':if((judge(x-1,y+2)&&mmap[x-1][y+2]=='k')||(judge(x+1,y+2)&&mmap[x+1][y+2]=='k'))
                         {
                             wina=1;
                             break;
                         }
                         if((judge(x-2,y+1)&&mmap[x-2][y+1]=='k')||(judge(x+2,y+1)&&mmap[x+2][y+1]=='k'))
                         {
                             wina=1;
                             break;
                         }
                         if((judge(x-2,y-1)&&mmap[x-2][y-1]=='k')||(judge(x+2,y-1)&&mmap[x+2][y-1]=='k'))
                         {
                             wina=1;
                             break;
                         }
                         if((judge(x-1,y-2)&&mmap[x-1][y-2]=='k')||(judge(x+1,y-2)&&mmap[x+1][y-2]=='k'))
                         {
                             wina=1;
                             break;
                         }
                         break;

                case 'B':
                        for(int i=1;i<=8-x;i++)
                         {
                             if(judge(x+i,y+i))
                             {
                                 if(mmap[x+i][y+i]=='k')
                                 {
                                    if(can1==0)
                                    {
                                       wina=1;
                                        break;
                                    }
                                 }
                                else if(mmap[x+i][y+i]!='.')
                                {
                                    can1=1;
                                }
                             }
                             if(judge(x+i,y-i))
                             {
                                 if(mmap[x+i][y-i]=='k')
                                 {
                                     if(can2==0)
                                     {
                                         wina=1;
                                         break;
                                     }

                                 }
                                 else if(mmap[x+i][y-i]!='.')
                                          can2=1;

                             }
                         }
                         if(wina==1)
                            break;

                         for(int i=1;i<=x-1;i++)
                         {
                             if(judge(x-i,y+i))
                             {
                                 if(mmap[x-i][y+i]=='k')
                                 {
                                    if(can3==0)
                                    {
                                        wina=1;
                                        break;

                                    }
                                 }
                                 else if(mmap[x-i][y+i]!='.')
                                 {
                                     can3=1;
                                 }

                             }
                             if(judge(x-i,y-i))
                             {
                                 if(mmap[x-i][y-i]=='k')
                                 {
                                     if(can4==0)
                                     {
                                          wina=1;
                                          break;
                                     }
                                 }
                                 else if(mmap[x-i][y-i]!='.')
                                 {
                                     can4=1;
                                 }

                             }

                         }
                         if(wina==1)
                            break;
                        break;
                case 'R':for(int i=1;i<=x-1;i++) //向上
                            {
                                /*if(judge(x-i,y)==false)
                                    continue;*/
                                if(mmap[x-i][y]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x-i][y]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                            for(int i=1;i<=8-x;i++) //向下
                            {
                                /*if(judge(x+i,y)==false)
                                    continue;*/
                                if(mmap[x+i][y]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x+i][y]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                            for(int j=1;j<=y-1;j++) //向左
                            {
                                /*if(judge(x,y-j)==false)
                                    continue;*/
                                if(mmap[x][y-j]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x][y-j]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                            for(int j=1;j<=8-y;j++)//向右
                            {
                                /*if(judge(x,y+j)==false)
                                    continue;*/
                                if(mmap[x][y+j]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x][y+j]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                        break;

                case 'Q':
                        for(int i=1;i<=8-x;i++)
                         {
                             if(judge(x+i,y+i))
                             {
                                 if(mmap[x+i][y+i]=='k')
                                 {
                                    if(can1==0)
                                    {
                                       wina=1;
                                        break;
                                    }
                                 }
                                else if(mmap[x+i][y+i]!='.')
                                {
                                    can1=1;
                                }
                             }
                             if(judge(x+i,y-i))
                             {
                                 if(mmap[x+i][y-i]=='k')
                                 {
                                     if(can2==0)
                                     {
                                         wina=1;
                                         break;
                                     }

                                 }
                                 else if(mmap[x+i][y-i]!='.')
                                          can2=1;

                             }
                         }
                         if(wina==1)
                            break;


                         for(int i=1;i<=x-1;i++)
                         {
                             if(judge(x-i,y+i))
                             {
                                 if(mmap[x-i][y+i]=='k')
                                 {
                                    if(can3==0)
                                    {
                                        wina=1;
                                        break;

                                    }
                                 }
                                 else if(mmap[x-i][y+i]!='.')
                                 {
                                     can3=1;
                                 }

                             }
                             if(judge(x-i,y-i))
                             {
                                 if(mmap[x-i][y-i]=='k')
                                 {
                                     if(can4==0)
                                     {
                                          wina=1;
                                          break;
                                     }
                                 }
                                 else if(mmap[x-i][y-i]!='.')
                                 {
                                     can4=1;
                                 }

                             }

                         }
                         if(wina==1)
                            break;

                         for(int i=1;i<=x-1;i++) //向上
                            {
                                /*if(judge(x-i,y)==false)
                                    continue;*/
                                if(mmap[x-i][y]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x-i][y]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                            for(int i=1;i<=8-x;i++) //向下
                            {
                                /*if(judge(x+i,y)==false)
                                    continue;*/
                                if(mmap[x+i][y]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x+i][y]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                            for(int j=1;j<=y-1;j++) //向左
                            {
                                /*if(judge(x,y-j)==false)
                                    continue;*/
                                if(mmap[x][y-j]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x][y-j]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                            for(int j=1;j<=8-y;j++)//向右
                            {
                                /*if(judge(x,y+j)==false)
                                    continue;*/
                                if(mmap[x][y+j]=='k')
                                {
                                    wina=1;
                                    break;
                                }
                                else if(mmap[x][y+j]!='.')
                                    break;
                            }
                            if(wina==1)
                                break;
                        break;

            }//switch
            if(wina==1)
                break;
        }
        if(wina==1)
        {
            printf("Game #%d: black king is in check.\n",++ca);
            continue;
        }
        if(wina==0&&winb==0&&flag)
            printf("Game #%d: no king is in check.\n",++ca);
            

    }while(flag);

    return 0;
}


 

Accagain
关注
专栏目录
uva 101 POJ 1208 The Blocks Problem 木块问题 vector模拟
水果君の日常
07-17 3060
挺水的模拟题，刚开始题目看错了，poj竟然过了。。。无奈。uva果断wa了 搞清题目意思后改了一下，过了uva。 题目要求模拟木块移动： 有n（0 move a onto b  在将a搬到b上之前，先把a和b上的积木放回原來的位置 move a over b在将a搬到b所在的那堆积木上前，先把a上的积木放回原來的位罝 pile a onto b 将包括a本身和上方的积木一起放到b上，在
习题6-10　10-20-30游戏（10-20-30, ACM/ICPC World Finals 1996, UVa246）
%%%
10-07 576
这是一道STL模拟题。水。 利用vector与deque的已有的等号运算符，可以实现题中draw的判断。其余的win与lose很好判断。 注意每次操作直到此堆不能再取回排为止。#include #include #include #include #include #include #include #include #include #include #include
uva 10196
chchlh的专栏
03-19 774
自己写的代码： //uva 10196. 测试通过。 #include #include #include using namespace std; bool checkchess(char a[8][8]) { int i,j; for(i=0;i { for(j=0;j { if(a[i][j]!='.') return true; } } return fa
UVa 10196 将军
kunkunTalk
05-03 520
The Problem Your task is to write a program that reads a chess board configuration and answers if there‘s a king under attack (i.e. "in check"). A king is in check if it‘s in a square which is atta
UVa 10196 - Check The Check
小白菜又菜
06-06 1188
题目：国际象棋，判断当前状态，哪一方被将军了。不会有同时被将军的情况。 分析：模拟。直接按照国际象棋的规则模拟即可。             把操作分成两种，单点判断和射线判断，写成函数减少公共代码，也降低错误率；             然后：兵、马、王（不用判断）都是单点判断，后、车、象都是射线判断。             每种情况，调用不同的方向向量即可。 说明：没有同时成立的情
UVA10196 Check The Check【模拟+回溯】
海岛Blog
04-28 924
Your task is to write a program that reads a chess board configuration and answers if there’s a king under attack (i.e. “in check”). A king is in check if it’s in a square which is attacked by an opon...
UVA 10196 - Check The Check (将军)
Cyibing的专栏
09-29 1190
UVA 10196 - Check The Check (将军) 题目描述 * 模拟棋盘。黑棋在棋盘的上半部分，用小写字母表示；白棋在下半部分，用大写字母表示。 * 一共有六种棋子。 * p ——> 只能走斜前方。即白棋只能走↖（左上），↗（右上）；黑棋只能走↙（左下），↘（右下） * r ——> 可以走垂直方向和水平方向上走，可以走任意格。 * b ——> 可以走对角线方向上走，可以走任意格。 * q ——> 可以走垂直方向、水平方向、对角线方向，可以走任意格。 * k ——> 可以走垂直方向、水平方向
uva 10196 Check The Check
weixin_34366546的博客
06-17 81
题目：10196 - Check The Check 思路：水题。。模拟  这个代码，前半部分是在数统机房上课的时候写的，挫了点，懒得改了。   #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cstring&gt; #include...
UVA 10196 Check The Check（模拟）
LYHVOYAGE的专栏
07-10 652
#include #include using namespace std; char Map[8][8]; // 表示国际象棋棋子的位置。 // 检查坐标为（king_x，king_y）的王是否在坐标为（x，y）的卒攻击范围内，注意进攻方向的不同。 bool check_Pp (int x, int y, int king_x, int king_y) { return (x - ki
UVA 804 Petri Net Simulation（算法竞赛入门经典，模拟）
qq_38232157的博客
09-01 284
算法竞赛入门经典177页，模拟 题目意思： np个节点 p[1], p[2], … , p[np], 每个节点有若干个牌子 token, 节点与节点之间不直接联系，中间间隔了 一个叫 发射站 trans 的玩意。每一节点向外只能指向一个 发射站。并且，一个节点指向同一个发射站若干次，节点就需要若干个 token 。 发射站也是不能直接相连， 多个节点，可以同时指向一个发射站; 每一个发射站，可能指向若干个 节点。 一个发射站，是否能点火发射，主要看看这个发射站 Trans ，指向 Trans 的每一个节点，
UVA 220 黑白棋
xiaojiao_6的博客
07-07 606
这道题按照题目描述的三种指令来模拟即可。 Q–退出并打印当前棋盘，L–先明确当前是黑棋还是白旗的回合，然后搜索棋盘的每个位置看是否可以放，M–先检查当前回合是否有合法位置，如果没有切换双方回合然后放置，放置后修改棋盘和棋子数目。注意输出格式，特别是’Black - xx White - yy’，是%2d格式。代码如下：#include<cstdio> #include<iostream> #inc
UVA 465 Overflow 高精度加法和乘法运算
Gatevin的专栏
07-04 774
题目给出多组数据，判断输入的两个数
简单浮点数除法模拟-hdu-4493-Tutor
cc_again的专栏
08-24 1447
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=4493 题目意思： 给小数点后两位的12个月的工资，求出平均工资，输出离小数点后第二位最近的两位小数，尾部零不输出。 解题思路： 这题一开始先除以12的话，有精度损失（比如都是12.4449999999999，结果算出来是12.45，应该是12.44），所以先模拟除以12，得到小数点后的
模拟 poj 3106 Flip and Turn
cc_again的专栏
01-08 1354
题目链接： http://poj.org/problem?id=3106 题目大意： 有一个m*n的矩阵，有10种操作，给一个操作串，求最后的矩阵。 操作'1'  ：沿主对角线翻转 行列交换 操作‘2’：沿副对角线翻转  行列交换 操作‘H'：沿水平方向翻转  操作’V‘：沿竖直方向翻转 操作’A‘：顺时针旋转90度，’B'：顺时针旋转180度，‘C'顺时针旋转270度。除18
模拟 poj 2166 Heapsort
cc_again的专栏
01-09 1209
题目链接： http://poj.org/problem?id=2166 题目大意： 求一个最大堆，使得经过堆排序的过程，交换的次数最多。 解题思路： 这个题昨天晚上想了会，没想出来，今早一起来就想出来喽。 分析：要想使得堆排序交换的次数最多，可以这样构造---每次让1都交换到最后。再分析易知，可以通过递推来得出当前的树结构。 假设现在一共有n个节点，显然save[1]=n,sa
并查集+模拟构造 sgu 449. Dendrograms
cc_again的专栏
01-11 1208
题目链接： http://acm.sgu.ru/problem.php?contest=0&problem=449 题目意思： 这题目真难读懂。 有n个节点，m条水平线，告诉每条水平线下竖线的数量以及每个竖线下的节点值。问怎样组合该树，使得该树结构清晰（竖线和横线不交叉）且靠左边的节点尽可能小。 解题思路： 先按水平线的高度从大到小排序，高度大的在下面，也就是从下往上处理，对每条水
模拟题 ural 1784. Rounders
cc_again的专栏
05-26 1206
题目链接： http://acm.timus.ru/problem.aspx?space=1&num=1784 题目意思： 一副牌分成4堆，每堆13张牌，每堆值从前至后为2-KA，牌色可能不一样。 现在可以有两种操作：1.从一堆中顶开始拿同一花色的k张，组成新的一堆。 2、从一堆中顶开始那同一花色的k张，放到当前堆的上面，要求是当前堆的第一张牌的值比要放堆的底的值大一。 问最少需要
模拟 uva 10881 - Piotr's Ants
cc_again的专栏
01-10 1205
题目链接： http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1822 题目意思： 在一个长为L的木棒上有n只蚂蚁，告诉每只蚂蚁的开始位置和开始运动方向，蚂蚁的速度都为单位长度每秒，求经过T秒后每只蚂蚁的运行情况。 若多只蚂蚁正相遇转向输出Turn
kickdown uva - 1588
最新发布
04-11
对于UVA - 1588题，"kickdown"是指在汽车驾驶员需要立刻踩下油门以逐渐加速至更高的速度。在这个问题中，需要将两个数字串比较，如果它们重叠，那么字符串重叠的部分需要被删除。需要自行编写算法并实现，以得到正确...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值