Ai 创想家 迷宫寻宝 最强代码（针对小学组的信息素养大赛）

已于 2024-07-20 11:11:59 修改
阅读量1.4k 收藏 7
点赞数 16
文章标签： 前端 开发语言 腾讯云 python
于 2024-07-20 11:10:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78933620/article/details/140567932
版权

接下来，我们开门见山，先揭露代码！！！

import api

history = []

multi = 1.25

midfield_addition = 3

sidefield_addition = 1.5

midfield = [(1,7),(2,7),(7,1),(7,2),(7,12),(7,13),(12,7),(13,7),

(3,3),(3,4),(3,5),(3,6),(3,7),(3,8),(3,9),(3,10),(3,11),

(4,3),(4,4),(4,5),(4,9),(4,10),(4,11),

(5,3),(5,4),(5,5),(5,6),(5,7),(5,8),(5,9),(5,10),(5,11),

(6,3),(6,5),(6,9),(6,11),

(7,3),(7,5),(7,9),(7,11),

(8,3),(8,5),(8,9),(8,11),

(9,3),(9,4),(9,5),(9,6),(9,7),(9,8),(9,9),(9,10),(9,11),

(10,3),(10,4),(10,5),(10,9),(10,10),(10,11),

(11,3),(11,4),(11,5),(11,6),(11,7),(11,8),(11,9),(11,10),(11,11),

]

sidefield = [(1,4),(1,5),(1,6),(1,8),(1,9),(1,10),

(4,1),(5,1),(6,1),(8,1),(9,1),(10,1),

(4,13),(5,13),(6,13),(8,13),(9,13),(10,13),

(13,4),(13,5),(13,6),(13,8),(13,9),(13,10),

]

def should_leave():

    e_row = api.get.exit(what="row")

    e_col = api.get.exit(what="col")

    path_len = api.check.path_len(row=e_row, col=e_col)

    my_energy = api.get.my(what="energy")

    if my_energy <= path_len + 1:

        return True

    else:

        return False

def get_update_value(item,dis,item_row,item_col):

    if item == "red_gem":

        value = 6

        value = value / (dis+1)

        if closer(item_row,item_col) == False:

            value = value / 100

        return value

    elif item == "yellow_gem":

        value = 1

        value = value / (dis+1)

        if closer(item_row,item_col) == False:

            value = value / 100

        return value

def closer(item_row,item_col):

    player = api.check.who_is_closer(row=item_row, col=item_col)

    me_closer = player.id == api.get.my("id")

    return me_closer

def update(context):

    my_row = api.get.my('row')

    my_col = api.get.my('col')

    enemy_row = api.get.enemy('row')

    enemy_col = api.get.enemy('col')

    up_row = my_row - 1

    up_col = my_col

    down_row = my_row + 1

    down_col = my_col

    left_row = my_row

    left_col = my_col - 1

    right_row = my_row

    right_col = my_col + 1

    yellow0_row = api.get.item(name="yellow_gem", n=0, what="row")

    yellow0_col = api.get.item(name="yellow_gem", n=0, what="col")

    yellow1_row = api.get.item(name="yellow_gem", n=1, what="row")

    yellow1_col = api.get.item(name="yellow_gem", n=1, what="col")

    yellow2_row = api.get.item(name="yellow_gem", n=2, what="row")

    yellow2_col = api.get.item(name="yellow_gem", n=2, what="col")

    yellow3_row = api.get.item(name="yellow_gem", n=3, what="row")

    yellow3_col = api.get.item(name="yellow_gem", n=3, what="col")

    red0_row = api.get.item(name="red_gem", n=0, what="row")

    red0_col = api.get.item(name="red_gem", n=0, what="col")

    red1_row = api.get.item(name="red_gem", n=1, what="row")

    red1_col = api.get.item(name="red_gem", n=1, what="col")

    up_score = 0

    down_score = 0

    left_score = 0

    right_score = 0

    maze = context.maze

    maze[yellow0_row][yellow0_col] = "yellow0_gem"

    maze[yellow1_row][yellow1_col] = "yellow1_gem"

    maze[yellow2_row][yellow2_col] = "yellow2_gem"

    maze[yellow3_row][yellow3_col] = "yellow3_gem"

    maze[red0_row][red0_col] = "red0_gem"

    maze[red1_row][red1_col] = "red1_gem"

    maze[my_row][my_col] = "me"

    maze[enemy_row][enemy_col] = "enemy"

    print("↑ 向上方向计算")

    if maze[up_row][up_col] == "WALL":

        up_score = 0

        print("道路不可通行","\n")

    else:

        yellow0_path = api.check.path(start=(up_row, up_col), end=(yellow0_row, yellow0_col))

        yellow1_path = api.check.path(start=(up_row, up_col), end=(yellow1_row, yellow1_col))

        yellow2_path = api.check.path(start=(up_row, up_col), end=(yellow2_row, yellow2_col))

        yellow3_path = api.check.path(start=(up_row, up_col), end=(yellow3_row, yellow3_col))

        red0_path = api.check.path(start=(up_row, up_col), end=(red0_row, red0_col))

        red1_path = api.check.path(start=(up_row, up_col), end=(red1_row, red1_col))

        yellow0_score = get_update_value("yellow_gem",len(yellow0_path),yellow0_row,yellow0_col)

        yellow1_score = get_update_value("yellow_gem",len(yellow1_path),yellow1_row,yellow1_col)

        yellow2_score = get_update_value("yellow_gem",len(yellow2_path),yellow2_row,yellow2_col)

        yellow3_score = get_update_value("yellow_gem",len(yellow3_path),yellow3_row,yellow3_col)

        red0_score = get_update_value("red_gem",len(red0_path),red0_row,red0_col)

        red1_score = get_update_value("red_gem",len(red1_path),red1_row,red1_col)

        up1_area = []

        if my_col == enemy_col:

            if my_row > enemy_row:

                for n in range(enemy_row+1,my_row):

                    up1_area.append(maze[n][my_col])

        if "yellow0_gem" in up1_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in up1_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in up1_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in up1_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in up1_area:

            red0_score = red0_score * multi

        if "red1_gem" in up1_area:

            red1_score = red1_score * multi

        up2_area = []

        if my_row < enemy_row:

            if my_col < enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(my_col,enemy_col+1):

                        up2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(enemy_col,my_col+1):

                        up2_area.append(maze[n][i])

        elif my_row > enemy_row:

            if my_col < enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(my_col,enemy_col+1):

                        up2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(enemy_col,my_col+1):

                        up2_area.append(maze[n][i])

        if "yellow0_gem" in up2_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in up2_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in up2_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in up2_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in up2_area:

            red0_score = red0_score * multi

        if "red1_gem" in up2_area:

            red1_score = red1_score * multi

        up3_area = []

        for (row,col) in midfield:

            up3_area.append(maze[row][col])

        if "yellow0_gem" in up3_area:

            yellow0_score = yellow0_score * midfield_addition

        if "yellow1_gem" in up3_area:

            yellow1_score = yellow1_score * midfield_addition

        if "yellow2_gem" in up3_area:

            yellow2_score = yellow2_score * midfield_addition

        if "yellow3_gem" in up3_area:

            yellow3_score = yellow3_score * midfield_addition

        if "red0_gem" in up3_area:

            red0_score = red0_score * midfield_addition

        if "red1_gem" in up3_area:

            red1_score = red1_score * midfield_addition

       

        up_lis = [yellow0_score,yellow1_score,yellow2_score,yellow3_score,red0_score,red1_score]

        best = max(up_lis)

        up_lis.remove(best)

        second_best = max(up_lis)

        up_score = best + second_best

        if context.round != 0:

            if history[len(history)-1] == "D":

                up_score = up_score * 0.95

        print(best,second_best)

        print("综合权重：", up_score,"\n")


 

    print("↓ 向下方向计算")

    if maze[down_row][down_col] == "WALL":

        down_score = 0

        print("道路不可通行","\n")

    else:

        yellow0_path = api.check.path(start=(down_row, down_col), end=(yellow0_row, yellow0_col))

        yellow1_path = api.check.path(start=(down_row, down_col), end=(yellow1_row, yellow1_col))

        yellow2_path = api.check.path(start=(down_row, down_col), end=(yellow2_row, yellow2_col))

        yellow3_path = api.check.path(start=(down_row, down_col), end=(yellow3_row, yellow3_col))

        red0_path = api.check.path(start=(down_row, down_col), end=(red0_row, red0_col))

        red1_path = api.check.path(start=(down_row, down_col), end=(red1_row, red1_col))

        yellow0_score = get_update_value("yellow_gem",len(yellow0_path),yellow0_row,yellow0_col)

        yellow1_score = get_update_value("yellow_gem",len(yellow1_path),yellow1_row,yellow1_col)

        yellow2_score = get_update_value("yellow_gem",len(yellow2_path),yellow2_row,yellow2_col)

        yellow3_score = get_update_value("yellow_gem",len(yellow3_path),yellow3_row,yellow3_col)

        red0_score = get_update_value("red_gem",len(red0_path),red0_row,red0_col)

        red1_score = get_update_value("red_gem",len(red1_path),red1_row,red1_col)

        down1_area = []

        if my_col == enemy_col:

            if my_row < enemy_row:

                for n in range(my_row+1,enemy_row):

                    down1_area.append(maze[n][my_col])

        if "yellow0_gem" in down1_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in down1_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in down1_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in down1_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in down1_area:

            red0_score = red0_score * multi

        if "red1_gem" in down1_area:

            red1_score = red1_score * multi

        down2_area = []

        if my_row < enemy_row:

            if my_col < enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(my_col,enemy_col+1):

                        down2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(enemy_col,my_col+1):

                        down2_area.append(maze[n][i])

        elif my_row > enemy_row:

            if my_col < enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(my_col,enemy_col+1):

                        down2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(enemy_col,my_col+1):

                        down2_area.append(maze[n][i])

        if "yellow0_gem" in down2_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in down2_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in down2_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in down2_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in down2_area:

            red0_score = red0_score * multi

        if "red1_gem" in down2_area:

            red1_score = red1_score * multi

        down3_area = []

        for (row,col) in midfield:

            down3_area.append(maze[row][col])

        if "yellow0_gem" in down3_area:

            yellow0_score = yellow0_score * midfield_addition

        if "yellow1_gem" in down3_area:

            yellow1_score = yellow1_score * midfield_addition

        if "yellow2_gem" in down3_area:

            yellow2_score = yellow2_score * midfield_addition

        if "yellow3_gem" in down3_area:

            yellow3_score = yellow3_score * midfield_addition

        if "red0_gem" in down3_area:

            red0_score = red0_score * midfield_addition

        if "red1_gem" in down3_area:

            red1_score = red1_score * midfield_addition

        down_lis = [yellow0_score,yellow1_score,yellow2_score,yellow3_score,red0_score,red1_score]

        best = max(down_lis)

        down_lis.remove(best)

        second_best = max(down_lis)

        down_score = best + second_best

        if context.round != 0:

            if history[len(history)-1] == "U":

                down_score = down_score * 0.95

        print(best,second_best)

        print("综合权重：", down_score)

    print("← 向左方向计算")

    if maze[left_row][left_col] == "WALL":

        left_score = 0

        print("道路不可通行","\n")

    else:

        yellow0_path = api.check.path(start=(left_row, left_col), end=(yellow0_row, yellow0_col))

        yellow1_path = api.check.path(start=(left_row, left_col), end=(yellow1_row, yellow1_col))

        yellow2_path = api.check.path(start=(left_row, left_col), end=(yellow2_row, yellow2_col))

        yellow3_path = api.check.path(start=(left_row, left_col), end=(yellow3_row, yellow3_col))

        red0_path = api.check.path(start=(left_row, left_col), end=(red0_row, red0_col))

        red1_path = api.check.path(start=(left_row, left_col), end=(red1_row, red1_col))

        yellow0_score = get_update_value("yellow_gem",len(yellow0_path),yellow0_row,yellow0_col)

        yellow1_score = get_update_value("yellow_gem",len(yellow1_path),yellow1_row,yellow1_col)

        yellow2_score = get_update_value("yellow_gem",len(yellow2_path),yellow2_row,yellow2_col)

        yellow3_score = get_update_value("yellow_gem",len(yellow3_path),yellow3_row,yellow3_col)

        red0_score = get_update_value("red_gem",len(red0_path),red0_row,red0_col)

        red1_score = get_update_value("red_gem",len(red1_path),red1_row,red1_col)

        left1_area = []

        if my_row == enemy_row:

            if my_col > enemy_col:

                for n in range(enemy_col+1,my_col):

                    left1_area.append(maze[my_row][n])

        if "yellow0_gem" in left1_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in left1_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in left1_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in left1_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in left1_area:

            red0_score = red0_score * multi

        if "red1_gem" in left1_area:

            red1_score = red1_score * multi

        left2_area = []

        if my_row < enemy_row:

            if my_col < enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(my_col,enemy_col+1):

                        left2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(enemy_col,my_col+1):

                        left2_area.append(maze[n][i])

        elif my_row > enemy_row:

            if my_col < enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(my_col,enemy_col+1):

                        left2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(enemy_col,my_col+1):

                        left2_area.append(maze[n][i])

        if "yellow0_gem" in left2_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in left2_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in left2_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in left2_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in left2_area:

            red0_score = red0_score * multi

        if "red1_gem" in left2_area:

            red1_score = red1_score * multi

        left3_area = []

        for (row,col) in midfield:

            left3_area.append(maze[row][col])

        if "yellow0_gem" in left3_area:

            yellow0_score = yellow0_score * midfield_addition

        if "yellow1_gem" in left3_area:

            yellow1_score = yellow1_score * midfield_addition

        if "yellow2_gem" in left3_area:

            yellow2_score = yellow2_score * midfield_addition

        if "yellow3_gem" in left3_area:

            yellow3_score = yellow3_score * midfield_addition

        if "red0_gem" in left3_area:

            red0_score = red0_score * midfield_addition

        if "red1_gem" in left3_area:

            red1_score = red1_score * midfield_addition

        left_lis = [yellow0_score,yellow1_score,yellow2_score,yellow3_score,red0_score,red1_score]

        best = max(left_lis)

        left_lis.remove(best)

        second_best = max(left_lis)

        left_score = best + second_best

        if context.round != 0:

            if history[len(history)-1] == "R":

                left_score = left_score * 0.95

        print(best,second_best)

        print("综合权重：", left_score)


 

    print("→ 向右方向计算")

    if maze[right_row][right_col] == "WALL":

        right_score = 0

        print("道路不可通行","\n")

    else:

        yellow0_path = api.check.path(start=(right_row, right_col), end=(yellow0_row, yellow0_col))

        yellow1_path = api.check.path(start=(right_row, right_col), end=(yellow1_row, yellow1_col))

        yellow2_path = api.check.path(start=(right_row, right_col), end=(yellow2_row, yellow2_col))

        yellow3_path = api.check.path(start=(right_row, right_col), end=(yellow3_row, yellow3_col))

        red0_path = api.check.path(start=(right_row, right_col), end=(red0_row, red0_col))

        red1_path = api.check.path(start=(right_row, right_col), end=(red1_row, red1_col))

        yellow0_score = get_update_value("yellow_gem",len(yellow0_path),yellow0_row,yellow0_col)

        yellow1_score = get_update_value("yellow_gem",len(yellow1_path),yellow1_row,yellow1_col)

        yellow2_score = get_update_value("yellow_gem",len(yellow2_path),yellow2_row,yellow2_col)

        yellow3_score = get_update_value("yellow_gem",len(yellow3_path),yellow3_row,yellow3_col)

        red0_score = get_update_value("red_gem",len(red0_path),red0_row,red0_col)

        red1_score = get_update_value("red_gem",len(red1_path),red1_row,red1_col)

        right1_area = []

        if my_row == enemy_row:

            if my_col < enemy_col:

                for n in range(enemy_col+1,my_col):

                    right1_area.append(maze[my_row][n])

        if "yellow0_gem" in right1_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in right1_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in right1_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in right1_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in right1_area:

            red0_score = red0_score * multi

        if "red1_gem" in right1_area:

            red1_score = red1_score * multi

        right2_area = []

        if my_row < enemy_row:

            if my_col < enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(my_col,enemy_col+1):

                        right2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(my_row,enemy_row+1):

                    for i in range(enemy_col,my_col+1):

                        right2_area.append(maze[n][i])

        elif my_row > enemy_row:

            if my_col < enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(my_col,enemy_col+1):

                        right2_area.append(maze[n][i])

            elif my_col > enemy_col:

                for n in range(enemy_row,my_row+1):

                    for i in range(enemy_col,my_col+1):

                        right2_area.append(maze[n][i])

        if "yellow0_gem" in right2_area:

            yellow0_score = yellow0_score * multi

        if "yellow1_gem" in right2_area:

            yellow1_score = yellow1_score * multi

        if "yellow2_gem" in right2_area:

            yellow2_score = yellow2_score * multi

        if "yellow3_gem" in right2_area:

            yellow3_score = yellow3_score * multi

        if "red0_gem" in right2_area:

            red0_score = red0_score * multi

        if "red1_gem" in right2_area:

            red1_score = red1_score * multi

        right3_area = []

        for (row,col) in midfield:

            right3_area.append(maze[row][col])

        if "yellow0_gem" in right3_area:

            yellow0_score = yellow0_score * midfield_addition

        if "yellow1_gem" in right3_area:

            yellow1_score = yellow1_score * midfield_addition

        if "yellow2_gem" in right3_area:

            yellow2_score = yellow2_score * midfield_addition

        if "yellow3_gem" in right3_area:

            yellow3_score = yellow3_score * midfield_addition

        if "red0_gem" in right3_area:

            red0_score = red0_score * midfield_addition

        if "red1_gem" in right3_area:

            red1_score = red1_score * midfield_addition

        right_lis = [yellow0_score,yellow1_score,yellow2_score,yellow3_score,red0_score,red1_score]

        best = max(right_lis)

        right_lis.remove(best)

        second_best = max(right_lis)

        right_score = best + second_best

        if context.round != 0:

            if history[len(history)-1] == "L":

                right_score = right_score * 0.95

        print(best,second_best)

        print("综合权重：", right_score)



 

    if should_leave():

        print("第", context.round, "回合，我要离开了")

        e_row = api.get.exit("row")

        e_col = api.get.exit("col")

        return api.check.next((e_row, e_col))

    else:

        all_scores = [up_score,down_score,left_score,right_score]

        max_score = max(all_scores)

        if up_score == max_score:

            print("第", context.round, "回合，我要向上走","\n")

            history.append("U")

            return "U"

        elif down_score == max_score:

            print("第", context.round, "回合，我要向下走","\n")

            history.append("D")

            return "D"

        elif left_score == max_score:

            print("第", context.round, "回合，我要向左走","\n")

            history.append("L")

            return "L"

        elif right_score == max_score:

            print("第", context.round, "回合，我要向右走","\n")

            history.append("R")

            return "R"

稍微有点长，希望不介意。。。

本策略须搭配其他策略相互进行，不可单独使用。

还是那句话：如果想借鉴使用，麻烦先点个赞再借鉴。如果因此导致失败，本人概不负责。

作者是个小学生，所以帖子里常常有不完善的地方。
如果有什么待改进的地方请在评论区提出建议，我会感激不尽。

好了，今天的帖子到此结束！！！

Flash The Dash
关注
AI创想家的迷宫寻宝代码好用的，自己的上分太匮乏了（想加入动态查找在么加）
2201_76097964的博客
05-07 4461
print("****************************正在进行的坐标为********************",path[1][0],path[1][1])print("最少宝石的价值性为",max_b,"目标价值为",max_path)print("最少宝石的价值性为",max_b,"目标价值为",max_path)print("识别到数量最少宝石",a[1][0],"一共有",a[1][1])print("识别到数量最少宝石",a[0][0],"一共有",a[0][1])
C＃迷宫代码，挺不错的
08-08
C＃ 迷宫代码，有兴趣可以参考一下，C＃ 迷宫代码，有兴趣可以参考一下
世界比赛冠军代码
02-23
经典啊不看后悔 方法：cmd debug> c:a.txt
AI创想家，迷宫寻宝
qq_35738121的博客
06-19 3128
print(f'最有价值物品: [Value = {bestValue:.2f}][Item = {bestItem}]')print(f'第{round}回合, 待收集的宝石: {ret}')# 计算物品附近的宝石, 优先前往资源丰富的区域。# 如果敌人正在远离宝石。# 否则敌人正在靠近宝石。# 如果敌人正在远离宝石。# 否则敌人正在靠近宝石。else: # 如果敌人离宝石更远。# 得到成套宝石中, 还缺少的宝石名称。# 如果敌人离宝石更近。# 获取玩家的宝石收集情况。# 如果是待收集的宝石。
scratch游戏制作-迷宫寻宝.docx
12-05
scratch游戏制作-迷宫寻宝.docx
迷宫寻宝源码
08-18
迷宫寻宝源码
学习5 游戏中的人工智能（迷宫寻宝）
purers的博客
09-04 5857
说明： 课程教材《计算机游戏程序设计》（基础篇）（第3版） 提供示例代码，而课程实验在示例代码的基础上提出更高的实验要求。除此之外，本人也会额外加入些个人创意，希望同学们在参考之余也能加入自己的想法。 实现效果： （因为雾效粒子太逼真导致gif动图随便一录就几十M，而博客里只能上传5m以下的图……费劲功夫减时长 减帧数 减质量才弄出一张……） 实验报告： 一、实验目的与要求 ...
实验项目三：基于A*搜索算法迷宫游戏开发的源代码
qq_58364169的博客
12-27 3179
package Maze; import javax.swing.*; import java.awt.*; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.util.ArrayList; import java.util.List; import java.util.Random; import java.util.Stack; class Node { public int x,y.
【ACM】算法题-迷宫寻宝(宽度搜索)(C++)
Qiqy 的博客
08-14 1781
迷宫寻宝 题目 一个叫ACM的寻宝者找到了一个藏宝图，它根据藏宝图找到了一个迷宫，不限时间和步数，当然也没有陷阱，请你判断他能不能顺利的得到宝藏。 输入 多组输入 每组测试数据的第一行包含了两个整数M,N(1<N,M<20)（n=0&&m=0表示输入结束），分别代表了迷宫的行和列。接下来的M每行有N个字符，描述了迷宫的布局。其中每个字符的含义如下： .表示可以走的路 S:表示ACM的出发点 G表示宝藏的位置 #表示这里有墙，ACM无法进入或者穿过。 输出 每行输出一个YES表示A
迷宫寻宝（一）
chao887062的专栏
06-29 1050
迷宫寻宝（一） http://acm.nyist.net/JudgeOnline/problem.php?pid=82 利用bfs来进行深度搜索，不过我的这个程序写得很烂 这是我的： #include"stdio.h" #include"string.h" int v[22][22],q1[409],q2[409],key[6],newx[4]={-1,0,1,0},newy[4]={0,
深度优先搜索之迷宫寻宝
qq_39034977的博客
12-02 1210
关于深度优先算法的一个应用
全国青少年信息素养大赛2023年python·选做题模拟一卷
IT_Scratch的博客
04-09 2153
一、单选题1. 下面程序执行完毕后，最终的结果是？（ ）b=[]c=[]s=a.pop()else:print(b)print(c)题型：单选题答案：B难度：困难试题解析：循环中套条件，又与列表进行结合，本题的意思是从a列表的最后一个元素开始移除，如果这个元素是偶数那么添加到b列表中，不是就添加到c列表中，所以选择B选项2. 以下程序的运行结果是？（ ）l =["兰溪","金华","武义","永康","磐安","东阳","义乌","浦江"]if"义"in s:print(s)
ProblemA 迷宫寻宝 -中北比赛
BoomMan
11-23 1327
这个代码参考了题解，以及其他大神的代码。因为网上没有代码，所以就把自己的代码贴上，如有雷同，请谅解！有什么问题可以一起研究讨论 #include int HouseMoney[1001][101];//每个房间的财富 int HouseDo[1001][101];//每个房间的消耗氧气 int MyMoney[1001][101][1001] = { 0 };//到达该房间是携带的最大
L1-064 估值一亿的AI核心代码 （2019天梯赛 1-8）
无知的渣渣的博客
04-06 4429
L1-064估值一亿的AI核心代码（20分) 以上图片来自新浪微博。 本题要求你实现一个稍微更值钱一点的 AI 英文问答程序，规则是： 无论用户说什么，首先把对方说的话在一行中原样打印出来； 消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉； 把原文中所有大写英文字母变成小写，除了I； 把原文中所有独立的can ...
迷宫寻宝（自编简单版）
ding7530的博客
06-26 342
　　nyoj - 迷宫寻宝(1) 我觉得有点难...我将其改简单一些。 　　题目描述：与原题基本差不多，但开门条件改一下，每个门只需要一把钥匙即可打开，一把钥匙可以开所有对应的门。 　　这样就简单很多啦。。。其实只是不想之前写的那个错代码没用处QwQ... 　　思路：路过钥匙时就将门的状态置为可打开，这样遇到门就可以正常处理了，如果门离起点比钥匙近，比如： S . A G ...
迷宫寻宝路线
panpanpan17452的博客
08-02 288
迷宫寻宝路线
C#迷宫代码
wenaiqian520的博客
11-02 1898
int Player_x = 0; int Player_y = 0; int[,] intArray_2 = new int[20, 20]{   {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},           {1,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,1,1,1},           {1,0,0,0,1,1,0
ai创想家足球 代码
最新发布
09-09
AI创想家足球是一种将人工智能技术应用于足球比赛模拟的项目，它通常涉及到机器学习、深度学习、图像处理、传感器数据处理等多个技术领域。在这个项目中，AI系统能够分析比赛中的各种数据，如球员的位置、速度、传球路线、射门意图等，并根据这些数据做出预测或决策，模拟真实的足球比赛。 由于“AI创想家足球 代码”这个表述可能涉及到多个不同的实现和项目，没有一个统一的代码示例。但是，我们可以描述一个简化的代码概念，假设有一个AI足球系统，它包含以下几个关键部分： 1. 数据收集模块：负责收集比赛中的实时数据，包括球员的位置、速度、球的位置等。 2. 数据处理模块：对收集到的数据进行处理，可能包括数据清洗、特征提取等步骤。 3. 决策模型：利用机器学习算法根据处理后的数据进行决策，如预测对手的传球路线，决定最佳的防守位置或进攻策略。 4. 控制输出模块：将决策结果转化为对球员的控制指令，实现自动化的比赛行为。 以下是一个非常简化的伪代码示例，描述了上述概念中的决策模型部分： ```python # 假设我们有一个机器学习模型已经训练好 class FootballAIModel: def __init__(self): # 加载预先训练好的模型 self.model = load_pretrained_model() def make_decision(self, game_data): # 对输入的比赛数据进行处理 processed_data = preprocess(game_data) # 利用模型进行决策 prediction = self.model.predict(processed_data) return prediction # 使用AI模型进行决策 ai_model = FootballAIModel() game_data = get_current_game_data() decision = ai_model.make_decision(game_data) perform_action(decision) ```
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值