HDU 5374 Tetris 模拟俄罗斯方块

最新推荐文章于 2019-12-05 18:12:38 发布
最新推荐文章于 2019-12-05 18:12:38 发布
阅读量883 收藏 1
点赞数
分类专栏： ACM_Simulation HDU 文章标签： HDU 5374 Tetris 俄罗斯方块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gatevin/article/details/47425485
版权

题目大意：

就是俄罗斯方块然后旋转, 向左右移动, 向下掉, 然后模拟求按照给定序列的操作能消除多少行...


大致思路：

就是模拟一下各个步骤的操作...按照题目说的steep1, 2, 3, 4一步步来就行了

其实就是暴力模拟...然后个人表示写的时候刚开始没想怎么设计比较方便...直接暴力模拟了...然后越写越多...然后已经没法回头了...于是强行写了下去....

最后还是在结束前5分钟调过了....表示写模拟之前应该多想一下怎么设计更优的....

于是就写了好长好长.......留个题解纪念一下.....逗比地写了好久


代码如下：

Result  :  Accepted      Memory  :  1584 KB     Time  :  0 ms

#include <map>
#include <cmath>
#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>


using namespace std;
char seq[1010];
int type[1010];
int maz[20][20];
int LS;
int now;
int ans;
int N;

void init()
{
    memset(maz, 0, sizeof(maz));
}
void out(){
    return;
    getchar();
    system( "cls" );
    cout << now << " " << seq[now] <<  endl;
    for( int i = 12 ; i ; i -- )
    {
        for( int j = 1 ; j <= 9 ; j ++ )
            printf("%d ",maz[j][i] );
        puts("");
    }
}
int tmp[20][20];
void disappear()
{
out();
    memset(tmp, 0, sizeof(tmp));
    int nx = 1;
    for(int y = 1; y <= 12; y++)
    {
        int cnt = 0;
        for(int x = 1; x <= 9; x++)
            if(maz[x][y]) cnt++;
        if(cnt == 9)
        {
            ans++;
        }
        else
        {
            for(int i = 1; i <= 9; i++)
                tmp[i][nx] = maz[i][y];
            nx++;
        }
    }
    memset(maz, 0, sizeof(maz));
    for(int j = 1; j <= 9; j++)
        for(int i = 1; i < nx; i++)
            maz[j][i] = tmp[j][i];
out();
    return;
}

void OO()
{
    int midx = 4, midy = 9;//step 1
    maz[midx][midy] = maz[midx][midy + 1] = maz[midx + 1][midy] = maz[midx + 1][midy + 1] = 1;//square
    while(now < LS)//seq[now]
    {
out();
        if(seq[now] == 'w')//step2
        {
            ;//rotate
        }
        else if(seq[now] == 'a')
        {
            //move left
            if(midx - 1 >= 1 && !maz[midx - 1][midy] && !maz[midx - 1][midy + 1])
            {
                maz[midx - 1][midy] = maz[midx - 1][midy + 1] = 1;
                maz[midx + 1][midy] = maz[midx + 1][midy + 1] = 0;
                midx--;
            }
            else ;//do nothing
        }
        else if(seq[now] == 'd')
        {
            if(midx + 1 + 1 <= 9 && !maz[midx + 2][midy] && !maz[midx + 2][midy + 1])
            {
                maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 1;
                maz[midx][midy] = maz[midx][midy + 1] = 0;
                midx++;
            }
            else ;//do nothing
        }
        else if(seq[now] == 's')
        {
            if(midy - 1 >= 1 && maz[midx][midy - 1] == 0 && maz[midx + 1][midy - 1] == 0)
            {
                maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
                maz[midx][midy + 1] = maz[midx + 1][midy + 1] = 0;//move down
                midy--;
            }
            else ;//do nothing
        }
        now++;//next command

        //fall a unit
        if(midy - 1 >= 1 && maz[midx][midy - 1] == 0 && maz[midx + 1][midy - 1] == 0)//step3
        {
            maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
            maz[midx][midy + 1] = maz[midx + 1][midy + 1] = 0;
            midy--;
        }
        else
        {
            break;//jump to step4
        }
    }
    disappear();//step4
    return;
}

void II()
{
    int midx = 4, midy = 9;
    for(int i = 0; i < 4; i++)
        maz[midx][midy + i] = 1;//Line
    int cas = 0;//shuzhe
    while(now < LS)
    {
out();
        if(seq[now] == 'w')
        {
            if(cas == 0)
            {
                bool ok = 1;
                for(int i = 1; i <= 3; i++)
                {
                    if(midx + i > 9 || maz[midx + i][midy] == 1)
                    {
                        ok = 0;
                        break;
                    }
                }
                if(!ok) ;//do nothing
                else//switch from 0 to 1
                {
                    for(int i = 1; i <= 3; i++)
                        maz[midx][midy + i] = 0;
                    for(int i = 1; i <= 3; i++)
                        maz[midx + i][midy] = 1;
                    cas = 1;
                }
            }
            else//cas == 1
            {
                bool ok = 1;
                for(int i = 1; i <= 3; i++)
                {
                    if(maz[midx][midy + i] == 1)
                    {
                        ok = 0;
                        break;
                    }
                }
                if(!ok);//do nothing
                else//switch from 1 to 0
                {
                    for(int i = 1; i <= 3; i++)
                        maz[midx][midy + i] = 1;
                    for(int i = 1; i <= 3; i++)
                        maz[midx + i][midy] = 0;
                    cas = 0;
                }
            }
        }
        else if(seq[now] == 'a')//move left
        {
            if(cas == 0)//
            {
                bool ok = 1;
                for(int i = 0; i < 4; i++)
                    if(midx - 1 < 1 || maz[midx - 1][midy + i] == 1)
                    {
                        ok = 0;
                        break;
                    }
                if(!ok);//do nothing
                else//cas 0 move left
                {
                    for(int i = 0; i < 4; i++)
                    {
                        maz[midx - 1][midy + i] = 1;
                        maz[midx][midy + i] = 0;
                    }
                    midx--;
                }
            }
            else//cas == 1
            {
                if(midx - 1 < 1 || maz[midx - 1][midy] == 1);
                else
                {
                    maz[midx - 1][midy] = 1;
                    maz[midx + 3][midy] = 0;
                    midx--;
                }

            }
        }
        else if(seq[now] == 'd')//move right
        {
            if(cas == 0)//
            {
                bool ok = 1;
                for(int i = 0; i < 4; i++)
                    if(midx + 1 > 9 || maz[midx + 1][midy + i] == 1)
                    {
                        ok = 0;
                        break;
                    }
                if(!ok);//do nothing
                else//cas 0 move right
                {
                    for(int i = 0; i < 4; i++)
                    {
                        maz[midx + 1][midy + i] = 1;
                        maz[midx][midy + i] = 0;
                    }
                    midx++;
                }
            }
            else//cas == 1
            {
                if(midx + 4 > 9 || maz[midx + 4][midy] == 1);
                else
                {
                    maz[midx + 4][midy] = 1;
                    maz[midx][midy] = 0;
                    midx++;
                }
            }
        }
        else if(seq[now] == 's')//move down
        {
            if(cas == 0)//shuzhe
            {
                if(midy - 1 < 1 || maz[midx][midy - 1] == 1);//do nothing
                else
                {
                    maz[midx][midy + 3] = 0;
                    maz[midx][midy - 1] = 1;
                    midy--;
                }
            }
            else//cas == 1
            {
                int ok = 1;
                for(int i = 0; i < 4; i++)
                    if(midy - 1 < 1 || maz[midx + i][midy - 1] == 1)
                    {
                        ok = 0;
                        break;
                    }
                if(!ok);//do nothing
                else
                {
                    for(int i = 0; i < 4; i++)
                        maz[midx + i][midy - 1] = 1;
                    for(int i = 0; i < 4; i++)
                        maz[midx + i][midy] = 0;
                    midy--;
                }
            }
        }
        now++;//next command

        //fall a unit
        if(cas == 0)//step3
        {
            if(midy - 1 < 1 || maz[midx][midy - 1] == 1)
                break;//jump to step4
            else
            {
                maz[midx][midy + 3] = 0;
                maz[midx][midy - 1] = 1;
                midy--;
            }
        }
        else//cas == 1
        {
            int ok = 1;
            for(int i = 0; i < 4; i++)
                if(midy - 1 < 1 || maz[midx + i][midy - 1] == 1)
                {
                    ok = 0;
                    break;
                }
            if(!ok)
                break;//jump to step4
            else
            {
                for(int i = 0; i < 4; i++)
                    maz[midx + i][midy - 1] = 1;
                for(int i = 0; i < 4; i++)
                    maz[midx + i][midy] = 0;
                midy--;
            }
        }
    }
    disappear();//step4
}

void JJ()
{
    int midx = 4, midy = 9;//step1
    int cas = 0;
    maz[midx][midy] = maz[midx + 1][midy] = maz[midx + 2][midy] = maz[midx][midy + 1] = 1;
    while(now < LS)
    {
out();
        //step2
        if(seq[now] == 'w')//change
        {
            if(cas == 0)//0 to 1
            {
                if(maz[midx][midy + 2] == 1 || maz[midx + 1][midy + 2] == 1);
                else//can change
                {
                    maz[midx + 1][midy] = maz[midx + 2][midy] = 0;
                    maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 1;
                    cas = 1;
                }

            }
            else if(cas == 1)//1 to 2
            {
                if(maz[midx + 1][midy + 1] == 1 || maz[midx + 2][midy + 1] == 1 || maz[midx + 2][midy] == 1);
                else
                {
                    maz[midx][midy] = maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 0;
                    maz[midx + 1][midy + 1] = maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 1;
                    cas = 2;
                }
            }
            else if(cas == 2)//2 to 3
            {
                if(maz[midx][midy] == 1 || maz[midx + 1][midy] == 1 || maz[midx + 1][midy + 2] == 1);
                else
                {
                    maz[midx][midy] = maz[midx + 1][midy] = maz[midx + 1][midy + 2] = 1;
                    maz[midx][midy + 1] = maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 0;
                    cas = 3;
                }
            }
            else if(cas == 3)//3 to 0
            {
                if(maz[midx][midy + 1] == 1 || maz[midx + 2][midy] == 1);
                else
                {
                    maz[midx][midy + 1] = maz[midx + 2][midy] = 1;
                    maz[midx + 1][midy + 1] = maz[midx + 1][midy + 2] = 0;
                    cas = 0;
                }
            }
        }else if(seq[now] == 'a') //move left
        {
            if(cas == 0)//cas 0
            {
                if(midx - 1 < 1 || maz[midx - 1][midy] == 1 || maz[midx - 1][midy + 1] == 1);
                else
                {
                    maz[midx - 1][midy] = maz[midx - 1][midy + 1] = 1;
                    maz[midx][midy + 1] = maz[midx + 2][midy] = 0;
                    midx--;
                }
            }
            else if(cas == 1)
            {
                if(midx - 1 < 1 || maz[midx - 1][midy] || maz[midx - 1][midy + 1] || maz[midx - 1][midy + 2]);
                else
                {
                    maz[midx - 1][midy] = maz[midx - 1][midy + 1] = maz[midx - 1][midy + 2] = 1;
                    maz[midx][midy] = maz[midx][midy + 1] = maz[midx + 1][midy + 2] = 0;
                    midx--;
                }
            }
            else if(cas == 2)
            {
                if(midx - 1 < 1 || maz[midx - 1][midy + 1] || maz[midx + 1][midy]);
                else
                {
                    maz[midx - 1][midy + 1] = maz[midx + 1][midy] = 1;
                    maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 0;
                    midx--;
                }
            }
            else if(cas == 3)
            {
                if(midx - 1 < 1 || maz[midx - 1][midy] || maz[midx][midy + 1] || maz[midx][midy + 2]);
                else
                {
                    maz[midx - 1][midy] = maz[midx][midy + 1] = maz[midx][midy + 2] = 1;
                    maz[midx + 1][midy] = maz[midx + 1][midy + 1] = maz[midx + 1][midy + 2] = 0;
                    midx--;
                }
            }
        }
        else if(seq[now] == 'd') //move right
        {
            if(cas == 0)
            {
                if(midx + 3 > 9 || maz[midx + 3][midy] || maz[midx + 1][midy + 1]);
                else
                {
                    maz[midx + 3][midy] = maz[midx + 1][midy + 1] = 1;
                    maz[midx][midy] = maz[midx][midy + 1] = 0;
                    midx++;
                }
            }
            else if(cas == 1)
            {
                if(midx + 2 > 9 || maz[midx + 2][midy + 2] || maz[midx + 1][midy] || maz[midx + 1][midy + 1]);
                else
                {
                    maz[midx + 2][midy + 2] = maz[midx + 1][midy] = maz[midx + 1][midy + 1] = 1;
                    maz[midx][midy] = maz[midx][midy + 1] = maz[midx][midy + 2] = 0;
                    midx++;
                }
            }
            else if(cas == 2)
            {
                if(midx + 3 > 9 || maz[midx + 3][midy] || maz[midx + 3][midy + 1]);
                else
                {
                    maz[midx + 3][midy] = maz[midx + 3][midy + 1] = 1;
                    maz[midx][midy + 1] = maz[midx + 2][midy] = 0;
                    midx++;
                }
            }
            else if(cas == 3)
            {
                if(midx + 2 > 9 || maz[midx + 2][midy] || maz[midx + 2][midy + 1] || maz[midx + 2][midy + 2]);
                else
                {
                    maz[midx + 2][midy] = maz[midx + 2][midy +1] = maz[midx + 2][midy + 2] = 1;
                    maz[midx][midy] = maz[midx + 1][midy + 1] = maz[midx +1][midy + 2] = 0;
                    midx++;
                }
            }
        }
        else if(seq[now] == 's') //move down
        {
            if(cas == 0)
            {
                bool ok = 1;
                for(int i = 0; i < 3; i++)
                    if(midy - 1 < 1 || maz[midx + i][midy - 1])
                    {
                        ok = 0;
                        break;
                    }
                if(!ok);
                else
                {
                    for(int i = 0; i < 3; i++)
                        maz[midx + i][midy - 1] = 1;
                    maz[midx + 1][midy] = maz[midx + 2][midy] = maz[midx][midy + 1] = 0;
                    midy--;
                }
            }
            else if(cas == 1)
            {
                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy + 1]);
                else
                {
                    maz[midx][midy - 1] = maz[midx + 1][midy + 1] = 1;
                    maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 0;
                    midy--;
                }
            }
            else if(cas == 2)
            {
                if(midy - 1 < 1 || maz[midx + 2][midy - 1] || maz[midx][midy] || maz[midx + 1][midy]);
                else
                {
                    maz[midx + 2][midy - 1] = maz[midx][midy] = maz[midx + 1][midy] = 1;
                    maz[midx][midy + 1] = maz[midx + 1][midy + 1] = maz[midx + 2][midy + 1] = 0;
                    midy--;
                }
            }
            else if(cas == 3)
            {
                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy - 1]);
                else
                {
                    maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
                    maz[midx][midy] = maz[midx + 1][midy + 2] = 0;
                    midy--;
                }
            }
        }
        now++;//next command

        //fall a unit, step3
        if(4)
        {
            if(cas == 0)
            {
                bool ok = 1;
                for(int i = 0; i < 3; i++)
                    if(midy - 1 < 1 || maz[midx + i][midy - 1])
                    {
                        ok = 0;
                        break;
                    }
                if(!ok)
                    break;
                else
                {
                    for(int i = 0; i < 3; i++)
                        maz[midx + i][midy - 1] = 1;
                    maz[midx + 1][midy] = maz[midx + 2][midy] = maz[midx][midy + 1] = 0;
                    midy--;
                }
            }
            else if(cas == 1)
            {
                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy + 1])
                    break;
                else
                {
                    maz[midx][midy - 1] = maz[midx + 1][midy + 1] = 1;
                    maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 0;
                    midy--;
                }
            }
            else if(cas == 2)
            {
                if(midy - 1 < 1 || maz[midx + 2][midy - 1] || maz[midx][midy] || maz[midx + 1][midy])
                    break;
                else
                {
                    maz[midx + 2][midy - 1] = maz[midx][midy] = maz[midx + 1][midy] = 1;
                    maz[midx][midy + 1] = maz[midx + 1][midy + 1] = maz[midx + 2][midy + 1] = 0;
                    midy--;
                }
            }
            else if(cas == 3)
            {
                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy - 1])
                    break;
                else
                {
                    maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
                    maz[midx][midy] = maz[midx + 1][midy + 2] = 0;
                    midy--;
                }
            }
        }

    }
    disappear();//step4
}

void start()
{
    init();
    for(int i = 1; i <= N; i++)
    {
        switch(type[i])
        {
            case 0: OO(); break;
            case 1: II(); break;
            case 2: JJ(); break;
        }
    }
}

int main()
{
//    freopen( "a.c" , "r" , stdin );
    int T;
    scanf("%d", &T);
    for(int cas = 1; cas <= T; cas++)
    {
        scanf("%d", &N);
        scanf("%s", seq);
        for(int i = 1; i <= N; i++)
            scanf("%d", &type[i]);

//freopen( "CON" , "r" , stdin );
        LS = strlen(seq);
        now = 0;
        ans = 0;
        start();
        printf("Case %d: %d\n", cas,  ans);
        /*
        for(int i = 12; i >= 1; i--)
        {
            for(int j = 1; j <= 9; j++)
            cout<<maz[j][i];
            cout<<endl;
        }
        */
    }
    return 0;
}



Gatevin
关注
专栏目录
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu 5374 Tetris（模拟）
不慌不忙、不急不躁
08-12 933
题目链接：hdu 5374 Tetris 模拟，每次进行操作时判断操作是否合法，合法才执行，否则跳过。每次一个token落地，判断一下是否有消除整行。 #include #include #include using namespace std; /******* Token **********/ const int C[3] = {1, 2, 4}; const
HDU 5374 Tetris(模拟俄罗斯方块）
zgerbin
08-11 1281
Tetris God Wu enjoy coding some trivial games like Tetris.His Tetris is made up by 9 columns and 12 rows.  The game will prossess as following steps 1.a random token will appear ,and its specia
Multi-University 2015 #7 F（hdu 5374 Tetris）
unicornt的博客
06-26 476
题目链接题目大意俄罗斯方块。 有三种块，每种块都可以旋转： 有四种操作，可以将当前块左移（a），右移（d），旋转（w），下降（d）。 其实还有一种操作p，表示不动。 块会自然下降。 每个块的特殊块（绿点）开始时在(4,9) 如果当前操作不合法，那么忽略。 如果一排被填满了，那么删掉这行，上面的行就会掉下来，分数++。 求最终的分数。题解好久没做模拟题了~~ 首先要对每种
HDU 5374 Tetris
Mr.Phoebe的专栏
08-12 1075
唯一的坑点是#号 剩下就是细节了，我这里的姿势有点不太好，solve函数在中间return的时候没有将操作数的下标+1，导致查了半天…// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algorithm> #include <iostream> #include <ioman
hdu 5374 Tetris 模拟俄罗斯方块
旧时光
08-12 1120
题目链接： hdu5374 题意： 俄罗斯方块游戏, 给出一个玩家的操作序列(w,a,s,d,p), 和依次出现的n个方块的形状, 问最终玩家消除了几行. 解题思路: 大模拟,想清楚就好写了, 用一个数组保存 所有形状 所有状态下 四个点的相对位置 每进行一次操作时,判断是否合法（越界,重叠） 下落时判断是否重叠 ,如果重叠
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，其中游戏规则相当简单：计算机随机选择一个介于1到N之间的整数，玩家有若干次机会猜测这个数字，每次猜测后，计算机会给出提示，告诉玩家猜的数字是偏大...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
HDU 5374 Tetris 俄罗斯方块 模拟
None
08-23 1673
这道题是喜闻乐见的大模拟题。 题目大意：在一个9X12的格子中玩俄罗斯方块，给定所有可能的方块形态，给定方块的掉落顺序，给定操作,w表示旋转,a表示左移,b表示右移,d表示下落一格(实际下落两格),p表示pass(即下落一格)，输入数据保证不会GameOver，求最后的分数。 题意虽然简单，但是由于编程复杂度等众多原因，考场上写的人不多。这里有几个可以简化代码的trick，由于旋转最大循环节为
hdu 5374 Tetris（模拟俄罗斯方块）
小G的ACM之路
08-13 1060
题意： 俄罗斯方块想必大家都玩过，现在题目给出了3种俄罗斯方块。 O形，I形，L形 以及5种操作，w选择，a左移一位，d右移以为，w下移一位，p什么都不做。然后又给出了方块出现的序列，要求按所给出的操作能消除多少行。 解析： DRAW数组表示已(x,y)(x,y)为左下角，能在图上画出的形状。 然后模拟每个每个方块，直到当前方块不能动位置，在二维数组中标记方块，然后接下来选
HDU - 2280 Tetris Comes Back （状压DP）
LP_Cong
09-20 629
Tetris Comes Back Problem Description Working in corporation is toilsome and rest is important. In leisure time, WisKey like to play Tetris. The Tetris game in board is N*5, and there are 8 ki
【找规律】HDU-6554 Tetris
zhanggirlzhangboy的博客
12-05 368
注解 1、找规律。本题是Special Judge，也就是答案不唯一，只需要输出一种符合要求的答案即可。要想用凸型包围，行和列都必须是4的倍数才可以。若不是，就没有答案。如果行和列都是4的倍数，那么只需要按题目中给出的那种示例去输出答案即可。即，每个4*4的网格都按照题目中所给的方案输出。 代码 #include <iostream> using namespace std; ...
HDU 5381 The sum of gcd 离线处理+线段树
None
08-24 910
题意：给一组序列，多次询问，每次询问f(l,r)=∑ri=l∑rj=igcd(ai,ai+1....aj)f(l,r)=\sum_{i=l}^{r}\sum_{j=i}^{r}gcd(a_i,a_{i+1}....a_{j})最初在赛场上看到这道题的时候，就想离线处理，但是怎么也不会。原因是当时并不知道这题的一个性质：从一个下标为i的数向后的连续区间[i,i+1]、[i,i+2]...[i,n][i
HDU1760 A New Tetris Game【DFS】【博弈】
程序员充电站（itcharge）
02-11 1210
题目大意： 给你一个N*M的矩阵棋盘。数字0代表该位置可用，数字1代表该位置不可以。Lele和姐姐在这个 棋盘上下棋，每次在棋盘上放一个大小为2*2的正方形，棋子间不能相互叠加。两个人轮流放，每 次都按最优策略放正方形。轮到谁没有地方放置棋子了，就算谁输。若每次都是Lele先放，那么问 题来了：Lele是否一定能赢姐姐呢。 思路： 博弈中的必胜态：当前所能到达的状态能到达一个必败态，则当前状态为必胜态。 博弈中的必败态：若当前状态到达的所有状态都是必胜态，则当前状态为必败态。 这道题和简单的取石子游戏差不
JSP学生学籍管理系统设计与实现(源代码+论文+开题报告+外文翻译+答辩PPT).zip
09-21
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
省市区数据，完成三级联动，选择地区
09-21
省市区数据，完成三级联动，选择地区
机械原理课程设计网球自动捡球机.doc
最新发布
09-21
机械原理课程设计网球自动捡球机.doc
ACM HDU题目分类概要
还有一些题目使用了特定的算法或技术，如1028题的整数拆分采用母函数法，1033题和1057题的模拟，1054和1055题的二分匹配，以及1066题的找规律。 ACM HDU题目分类涵盖了算法和编程的多个方面，包括但不限于动态规划...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值