Rush Hour Puzzle

最新推荐文章于 2021-10-06 22:14:52 发布
最新推荐文章于 2021-10-06 22:14:52 发布
阅读量561 收藏 5
点赞数 1
分类专栏： 搜索 文章标签： bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/soul_mingling/article/details/108597560
版权
探讨了Rush Hour拼图游戏的算法解决方案，该游戏目标是通过移动其他车辆来让红色车辆完全离开棋盘。使用广度优先搜索(BFS)和矩阵哈希技术判断谜题是否能在10步内解决。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Rush Hour Puzzle

题目描述 ：
Rush Hour is a puzzle game invented by Nob Yoshigahara in the 1970s. It is now being manufactured by ThinkFun. The board is a 6 × 6 grid with grooves in the tiles to allow vehicles to slide. Cars and trucks are both one square wide, but cars are two squares long and trucks are three squares long. Vehicles can only be moved forward or backward along a straight line on the grid. The goal of the game is to get the only red car totally out through the exit of the board by moving the other vehicles out of its way. Figure 1 gives an example of Rush Hour puzzle.
在这里插入图片描述

Figure 1: An example of Rush Hour puzzle.
We give each vehicle of a puzzle a unique id, numbered from 1 to the number of vehicles, in which the red car’s id is 1. The board information of a puzzle is represented by a 6 × 6 matrix,named board matrix. Each entry of a board matrix is the id of the vehicle placed on that groove, and the entries are filled with 0 if there exists no vehicle on those grooves. The exit of the board is located at the right end side of the 3rd row. Figure 2 shows the board matrix corresponding to the puzzle in Figure 1.
Moving a piece (car or truck) by one unit (a groove) is called a step. A puzzle is easy if it can be solved (the red car totally out through the exit of the board) in no more than 10 steps.
Please write a program to judge whether a puzzle is easy or not.
在这里插入图片描述

Figure 2: The board matrix corresponding to the puzzle in Figure 1.

输入
The input contains 6 lines, each line indicates the content (6 integers separated by a blank) of each row of a board matrix.
输出
Output the minimum number of steps for solving the input puzzle if the puzzle is easy, otherwise output -1.
样例输入
0 2 0 6 6 0
0 2 0 0 7 0
0 3 1 1 7 0
0 3 4 4 8 0
0 5 5 5 8 0
0 0 0 0 0 0
样例输出
6
提示
• There are at most 10 vehicles on the board for each puzzle.
• Only the red car can be moved out of the board for each puzzle.
题目大意：车的长度由2和3，连续的非零数字代表一辆车，现在要把“1”代表的车移出去（出口固定在第三行末尾），一次移动一格，问把车移动出去的最小次数（注意移出去还要2次），若答案不存在或在10步以上，则输出-1。
表面意思，bfs加矩阵哈希（我用了map处理）。但我保证，这是我写过最长+最长时间的bfs搜索。。。

#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3)
#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
typedef queue<int> q_i;
typedef queue<string> q_s;
typedef queue<double> q_d;
typedef queue<ll> q_ll;
typedef queue<char> q_c;
typedef priority_queue<int> pq_i;
typedef priority_queue<string> pq_s;
typedef priority_queue<double> pq_d;
typedef priority_queue<ll> pq_ll;
typedef stack<int> s_i;
typedef stack<string> s_s;
typedef stack<double> s_d;
typedef stack<ll> s_ll;
typedef stack<char> s_c;
typedef map<ll,ll> m_ll_ll;
typedef map<int,ll> m_i_ll;
typedef map<int,int> m_i_i;
typedef map<string,ll> m_s_ll;
typedef map<char,int> m_c_i;
typedef map<char,ll> m_c_ll;
const ll INF=0x3f3f3f3f;
#define rep(i,l,r) for(ll i=l;i<=r;i++)
#define per(i,l,r) for(ll i=r;i>=l;i--)
#define eif else if
#define N 100005
#define mm(dp) memset(dp,0,sizeof(dp))
#define mm1(dp) memset(dp,-1,sizeof(dp))
#define mm2(dp) memset(dp,0x3f,sizeof(dp))
#define IT set<int>::iterator
#define fs(n) fixed<< setprecision(n)
//const double e=2.71828182845;
#define max(a,b) a>b?a:b
#define min(a,b) a<b?a:b
const double pi = acos(-1.0);
const int p=1e9+7;
inline ll read()
{
    ll s=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        s=s*10+ch-'0',ch=getchar();
    return s*w;
}
inline void write(ll x)
{
    if(x<0)
        putchar('-'),x=-x;
    if(x>9)
        write(x/10);
    putchar(x%10+'0');
}
float SqrtByCarmack( float number )
{
    int i;
    float x2, y;
    const float threehalfs = 1.5F;
    x2 = number * 0.5F;
    y  = number;
    i  = * ( int * ) &y;
    i  = 0x5f375a86 - ( i >> 1 );
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );
    y  = y * ( threehalfs - ( x2 * y * y ) );
    y  = y * ( threehalfs - ( x2 * y * y ) );
    return number*y;
}
ll qpow(ll a,ll b,ll mod)
{
    ll sum=1;
    while(b)
    {
        if(b%2==1)
        {
            sum=sum*a%mod;
        }
        b/=2;
        a=a*a%mod;
    }
    return sum;
}
int erfen(int *a,int start,int endd,int l)//小于等于l的最大值的角标
{
    int mid=(start+endd)/2;
    if((a[mid]<=l&&a[mid+1]>l)||(mid==endd&&a[mid]<=l))
        return mid;
    else if(a[mid]<=l)
        return erfen(a,mid+1,endd,l);
    else if(a[mid]>l)
    {
        if(start!=mid)
            return erfen(a,start,mid,l);
        else
            return start-1;
    }
}
ll prime[6] = {2, 3, 5, 233, 331};
ll qmul(ll x, ll y, ll mod)
{
    return (x * y - (long long)(x / (long double)mod * y + 1e-3) *mod + mod) % mod;
}
bool Miller_Rabin(ll p)
{
    if(p < 2)
        return 0;
    if(p != 2 && p % 2 == 0)
        return 0;
    ll s = p - 1;
    while(! (s & 1))
        s >>= 1;
    for(int i = 0; i < 5; ++i)
    {
        if(p == prime[i])
            return 1;
        ll t = s, m = qpow(prime[i], s, p);
        while(t != p - 1 && m != 1 && m != p - 1)
        {
            m = qmul(m, m, p);
            t <<= 1;
        }
        if(m != p - 1 && !(t & 1))
            return 0;
    }
    return 1;
}
ll gcd(ll x,ll y)
{
    if(y==0)
        return x;
    else
        return gcd(y,x%y);
}
typedef struct
{
    int a[7][7];
    int nm;
}STU;
typedef struct
{
    int a[7][7];
}STU1;
STU stu;
queue<STU>que;
map<string,int>mapp;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int cnt=0;
    int u[15];
    mm(u);
    int kk=0;
    rep(i,1,6)
    {
        rep(j,1,6)
        {
            cin>>stu.a[i][j];
            //stu1.a[i][j]=stu.a[i][j];
            u[stu.a[i][j]]++;
            cnt=max(cnt,stu.a[i][j]);
        }
    }
    int flag=0;
    stu.nm=0;
    que.push(stu);
    while(!que.empty())
    {
        STU stu0=que.front();
 
        kk++;
 
//        cout<<endl;
//        rep(i,1,6)
//        {
//            rep(j,1,6)
//            {
//                cout<<stu0.a[i][j]<<" ";
//            }
//            cout<<endl;
//        }
//        cout<<endl;
        que.pop();
        if(stu0.a[3][6]==1&&stu0.a[3][5]==1)
        {
            if(u[1]==2)
                cout<<stu0.nm+2<<'\n';
            else
                cout<<stu0.nm+3<<'\n';
            flag=1;
            break;
        }
        rep(k,1,cnt)
        {
            if(u[k]==2)
            {
                int v=0;
                int flagx1=0;
                int flagy1=0;
                int flagx2=0;
                int flagy2=0;
                rep(i,1,6)
                {
                    rep(j,1,6)
                    {
                        if(stu0.a[i][j]==k&&v==0)
                        {
                            flagx1=i;
                            flagy1=j;
                            v++;
                        }
                        eif(stu0.a[i][j]==k)
                        {
                            flagx2=i;
                            flagy2=j;
                            v++;
                            break;
                        }
                    }
                    if(v==2)
                        break;
                }
                //if(k==2)
                    //cout<<flagy1<<" "<<flagy2<<endl;
                if(flagy1==flagy2)
                {
                    int xx1=min(flagx1,flagx2);
                    int xx2=max(flagx1,flagx2);
                    int yy=flagy1;
                    //cout<<xx1-1<<endl;
                    if(xx1-1>0)
                    {
                        if(stu0.a[xx1-1][yy]==0)
                        {
                            //cout<<xx1-1<<" "<<yy<<" "<<k<<endl;
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(q==yy)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==xx1-1||p==xx1)
                                {
                                    stu1.a[p][yy]=stu0.a[p+1][yy];
                                }
                                eif(p==xx2)
                                {
                                    stu1.a[p][yy]=0;
                                }
                                else
                                    stu1.a[p][yy]=stu0.a[p][yy];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
 
                        }
                    }
 
                    if(xx2+1<7)
                    {
                        if(stu0.a[xx2+1][yy]==0)
                        {
                            //cout<<xx2+1<<" "<<yy<<" "<<k<<endl;
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(q==yy)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==xx2||p==xx2+1)
                                {
                                    stu1.a[p][yy]=stu0.a[p-1][yy];
                                }
                                eif(p==xx1)
                                {
                                    stu1.a[p][yy]=0;
                                }
                                else
                                    stu1.a[p][yy]=stu0.a[p][yy];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
 
 
                        }
                    }
                }
                else
                {
                    int yy1=min(flagy1,flagy2);
                    int yy2=max(flagy1,flagy2);
                    int xx=flagx1;
                    if(yy1-1>0)
                    {
                        if(stu0.a[xx][yy1-1]==0)
                        {
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(p==xx)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==yy1-1||p==yy1)
                                {
                                    stu1.a[xx][p]=stu0.a[xx][p+1];
                                }
                                eif(p==yy2)
                                {
                                    stu1.a[xx][p]=0;
                                }
                                else
                                    stu1.a[xx][p]=stu0.a[xx][p];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
                        }
                    }
                    if(yy2+1<7)
                    {
                        if(stu0.a[xx][yy2+1]==0)
                        {
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(p==xx)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==yy2||p==yy2+1)
                                {
                                    stu1.a[xx][p]=k;
                                }
                                eif(p==yy1)
                                {
                                    stu1.a[xx][p]=0;
                                }
                                else
                                    stu1.a[xx][p]=stu0.a[xx][p];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
                        }
                    }
                }
            }
 
 
            else
            {
                int v=0;
                int flagx1=0;
                int flagy1=0;
                int flagx2=0;
                int flagy2=0;
                int flagx3=0;
                int flagy3=0;
                rep(i,1,6)
                {
                    rep(j,1,6)
                    {
                        if(stu0.a[i][j]==k&&v==0)
                        {
                            flagx1=i;
                            flagy1=j;
                            v++;
                        }
                        eif(stu0.a[i][j]==k&&v==1)
                        {
                            flagx2=i;
                            flagy2=j;
                            v++;
                        }
                        eif(stu0.a[i][j]==k&&v==2)
                        {
                            flagx3=i;
                            flagy3=j;
                            v++;
                        }
                        if(v==3)
                            break;
                    }
                    if(v==3)
                        break;
                }
                if(flagy1==flagy2)
                {
                    int xx1=min(flagx1,flagx2);
                    xx1=min(xx1,flagx3);
                    int xx2=max(flagx1,flagx2);
                    xx2=max(xx2,flagx3);
                    int yy=flagy1;
 
                    if(xx1-1>0)
                    {
                        if(stu0.a[xx1-1][yy]==0)
                        {
                            //cout<<xx1-1<<" "<<yy<<" "<<k<<endl;
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(q==yy)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==xx1-1||p==xx1||p==xx1+1)
                                {
                                    stu1.a[p][yy]=stu0.a[p+1][yy];
                                }
                                eif(p==xx2)
                                {
                                    stu1.a[p][yy]=0;
                                }
                                else
                                    stu1.a[p][yy]=stu0.a[p][yy];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
                        }
 
 
 
                    }
                    if(xx2+1<7)
                    {
                        if(stu0.a[xx2+1][yy]==0)
                        {
                            //cout<<xx2+1<<" "<<yy<<" "<<k<<endl;
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(q==yy)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==xx2||p==xx2+1||p==xx2-1)
                                {
                                    stu1.a[p][yy]=k;
                                }
                                eif(p==xx1)
                                {
                                    stu1.a[p][yy]=0;
                                }
                                else
                                    stu1.a[p][yy]=stu0.a[p][yy];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
 
 
                        }
                    }
                }
                else
                {
                    int yy1=min(flagy1,flagy2);
                    yy1=min(yy1,flagy3);
                    int yy2=max(flagy1,flagy2);
                    yy2=max(yy2,flagy3);
                    int xx=flagx1;
                    if(yy1-1>0)
                    {
                        if(stu0.a[xx][yy1-1]==0)
                        {
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(p==xx)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==yy1-1||p==yy1||p==yy1+1)
                                {
                                    stu1.a[xx][p]=k;
                                }
                                eif(p==yy2)
                                {
                                    stu1.a[xx][p]=0;
                                }
                                else
                                    stu1.a[xx][p]=stu0.a[xx][p];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
                        }
                    }
                    if(yy2+1<7)
                    {
                        if(stu0.a[xx][yy2+1]==0)
                        {
                            STU stu1;
                            rep(p,1,6)
                            {
                                rep(q,1,6)
                                {
                                    if(p==xx)
                                        continue;
                                    else
                                        stu1.a[p][q]=stu0.a[p][q];
                                }
                            }
                            rep(p,1,6)
                            {
                                if(p==yy2||p==yy2+1||p==yy2-1)
                                {
                                    stu1.a[xx][p]=k;
                                }
                                eif(p==yy1)
                                {
                                    stu1.a[xx][p]=0;
                                }
                                else
                                    stu1.a[xx][p]=stu0.a[xx][p];
                            }
                            stu1.nm=stu0.nm+1;
                            string str="";
                            rep(i,1,6)
                            {
                                rep(j,1,6)
                                {
                                    char ch=(stu1.a[i][j]-'0');
                                    str=str+ch;
                                }
                            }
                            if(mapp[str]==0)
                            {
                                mapp[str]=1;
                                if(u[1]==2)
                                {
                                    if(stu1.nm<=8)
                                        que.push(stu1);
                                }
                                else
                                {
                                    if(stu1.nm<=7)
                                        que.push(stu1);
                                }
 
                            }
                        }
                    }
 
 
 
                }
            }
        }
    }
    if(flag==0)
        cout<<-1<<'\n';
    return 0;
}
upc A Rush Hour Puzzle bfs
DaNIelLAk的博客
09-12 286
题意：给定6*6矩阵，相同数字代表一辆车，且只能前后移动。出口在第三行最右边。问编号为1的车能不能出去。 看大佬们都讨论的dfs写的，比赛的时候我这个dfs菜鸡不会写，所以写了个bfs。 灵感来源于八数码问题，主要是借鉴了当时做八数码的时候，将矩阵转换成了一个字符串。这个题基本可以实现O(1)O(1)O(1)转移，但是比赛的时候瞎搞的，也没优化，完全可以把bfs中字符串转换成矩阵的一层循环优化掉。转移的时候从头遍历找到每个数字的第一个位置，所以这个数字代表的车辆一定是从这个数字向右延伸或者向左延伸得到的，.
2019-2020 ICPC Asia Taipei-Hsinchu Regional Contest
m0_49959202的博客
10-03 840
文章目录2019-2020 ICPC Asia Taipei-Hsinchu Regional ContestA.Rush Hour PuzzleC.Are They All Integers?D.TapiokaE.The League of Sequence DesignersH.Mining aJ.Automatic Control MachineK.Length of Bundle RopeL. Largest Quadrilateral 2019-2020 ICPC Asia Taipei-Hsin
rush-hour-puzzle-solver
03-22
高峰时间难题求解器
Gym - 102460A Rush Hour Puzzle(dfs迭代加深)
Falcon的博客
09-12 607
题目链接：点击查看 题目大意：给出一个 6 * 6 的矩阵，表示华容道的游戏界面，现在需要红色汽车(标号为 1 )从第三行最右端到达出口的最短时间，如果无解或者步数超过 10 输出 -1 题目分析：因为最多有十种不同的汽车，所以我们可以直接爆搜，时间复杂度大概 40^8？当然最坏情况肯定远远达不到，具体复杂度我也不太会算 爆搜的话，只需要搜每一步每一种车可能的情况即可，具体实现可以参考代码 需要注意的是，这个题目用 bfs 需要自己写一个结构体封装，然后每次转移状态的时候都需要频繁的调用构造函数，导
记忆化搜索（ 石油大学组队赛A: Rush Hour Puzzle）
平凡人Kalzn的博客
09-12 256
题意：如图，把一号车从出口（3，6）弄出去，最少多少步，（10步以上输出-1） 题解：没啥知识含量，就硬模拟，记录压缩状态dp[sta]，因为每个车都只会在自己所在的列、行移动，所以压缩是只记录一维就行。每个坐标最多6种情况（其实可以在针对车进行压缩，每个车都是4、5个情况。但是空间已经够了）。所以状态为6n6^n6n种，n为车的数量。然后就是模拟转移+记忆化搜索。 下面是ac代码： #include<iostream> #include<cstdlib> #include<.
Rush Hour Puzzle Solver-开源
04-27
高峰时间难题求解器是一个小型C ++程序，可以从文本文件中读取高峰时间板，并生成一个显示最短解决方案的漂亮的PostScript文件。
Sliding-Block-Puzzle:这是一个用 Java Swing 库实现的滑块益智游戏（类似于 Rush Hour 和 Traffic Jam 游戏）
07-01
Sliding Block Puzzles 是一款类似于 Rush Hour 的益智游戏，使用 Java Swing 库实现。 游戏由适合有限区域的许多棋子组成。 目标是将其中一个棋子（标记为“Z”的“目标棋子”）移动到特定位置。 通常，目标只能...
2021 ICPC Asia EC网络预选赛I、II
weixin_46064382的博客
10-06 588
1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.
Python高峰时间谜题求解器：压缩包子文件解析
标题 "rush-hour-puzzle-solver" 暗示了这个项目是一个解决特定难题（riddle 或 puzzle）的求解器，特别与高峰时间（rush-hour）相关。在IT领域中，这个问题很可能是指一个计算机程序或算法，用来解决一个类似于交通...
--Rush-Hour--:解决游戏RushHour的A *算法
03-29
--Rush-Hour--:解决游戏RushHour的A *算法
rushhour:用于高峰时间游戏的基于启发式的求解器
06-27
＃高峰时间 使用广度优先搜索解决高峰时间游戏的程序。 用法 rushhour模块提供了一个通用的RushHour类，任何搜索界面都可以使用它来确定新路径。 这允许创建新算法，例如最佳优先搜索或 A*。 rushhour.py文件还充当脚本，接受问题文件路径。 问题目录中提供了示例问题，可以使用以下命令运行： python rushhour.py problems/p1 该脚本将对示例问题执行广度优先搜索（最大深度为 100），并报告找到的解决方案数量、解决方案步骤以及搜索中访问的节点总数。 方法 广度优先搜索通过枚举板上的车辆并确定哪些车辆旁边有可以移动的空间来操作。 对于每个可以移动的车辆，电路板都会生成一个新的边缘状态。 确定难度 除了rushhour.py脚本，还有一个difficulty.py脚本。 这个脚本的界面和前者一样，它仍然需要一个问题文件的路径，但是这个脚本会根据游
热身赛补题A - Rush Hour Puzzle Gym - 102460A
weixin_46227016的博客
07-09 653
原题 Rush Hour is a puzzle game invented by Nob Yoshigahara in the 1970s. It is now being manufactured by ThinkFun. The board is a 6 × 6 grid with grooves in the tiles to allow vehicles to slide. Cars and trucks are both one square wide, but cars are two sq
[2019 ICPC Taipei-Hsinchu] A.Rush Hour Puzzle //bfs
晚樱
04-01 1238
题目链接 题意： 思路：//写过的最长的bfs [汗.jpg] #include<bits/stdc++.h> using namespace std; int a_[7][7],ans=11,cnt=1,c,sum; struct node{ int len; int u,pos,s,t; //u=1行，u=0列 node(){u=-1;s=7;} }v[20...
ICPC Asia Taipei-Hsinchu Regional 2019 Rush Hour Puzzle （矩阵哈希 + BFS）
OlaMins
07-18 877
Problem Description Rush Houris a puzzle game invented by Nob Yoshigahara in the19701970s. It is now being manufactured byThinkFun. The board is a6 \times 66×6grid with grooves in the tiles to a...
gym102460 Rush Hour Puzzle 2019ICPC Taipei
binarycopycode
09-09 225
https://codeforces.com/gym/102460 目标就是让1的右端点移动到(3,6)的位置，从(3,6)出去还要两步，那么最多就是移动8步，又因为最多只有10个物品，而且我们可以用hash标记棋盘的某个状态是否出现过，那么每次尝试移动每个物品，bfs就行了，最坏情况是(10*2)^8的状态，但是由于互相碰撞的原因,实际情况会少很多状态，30ms就跑过了 #include<bits/stdc++.h> using namespace std; typedef long l
浅谈Rush hour 类型解谜游戏最优解算法——使用 Zobrist Hash（佐布里斯特散列）
THUNDERDREAMER_OR的博客
02-14 935
基于模糊控制理论的汽车EPS双层控制器设计及仿真优化研究 · 控制器设计 参考
05-29
内容概要：本文探讨了如何设计一个基于模糊控制理论的双层控制器来优化汽车EPS（电动助力转向系统）的性能。EPS系统通过电子控制技术实现转向助力，提升驾驶的舒适性和操控性。文中详细介绍了PID控制算法的局限性以及引入模糊控制器的原因。模糊控制器作为双层控制器的上层，通过模糊推理机制处理不确定性问题并优化PID控制算法。最后，通过Simulink和MATLAB模型进行了仿真验证，证明了双层控制器的有效性。 适合人群：从事汽车工程、控制系统设计的研究人员和技术人员，特别是对模糊控制理论和EPS系统感兴趣的读者。 使用场景及目标：适用于希望深入了解EPS系统优化方法的研究人员和技术人员，旨在通过模糊控制理论改进现有控制算法，提高EPS系统的鲁棒性和适应性。 阅读建议：读者可以通过本文了解模糊控制理论在EPS系统中的应用，掌握双层控制器的设计思路，并通过提供的Simulink和MATLAB模型进行仿真实验，验证控制算法的效果。
基于PSO算法的IEEE33背靠背互联配电网无功优化策略研究：总损耗与电压偏差双目标优化
最新发布
05-29
内容概要：本文探讨了基于粒子群优化（PSO）算法，在三个IEEE33背靠背互联配电网中进行无功优化的方法。优化的目标是同时最小化系统的总损耗和电压偏差。文中详细介绍了优化对象（主变档位OTLC和电容器组CB）、优化算法的具体实现步骤以及关键代码片段。此外，还讨论了粒子更新、粒子筛除机制、SOP功率传输处理方法及其改进措施。实验结果显示，优化后的系统不仅显著降低了网损（日均23.7%），而且有效改善了电压分布，使OLTC和CB的动作次数均符合约束条件。 适合人群：电力系统研究人员、从事智能电网优化工作的工程师和技术人员。 使用场景及目标：适用于需要对配电网络进行无功优化的研究项目或工程应用，旨在提高配电网运行效率，减少能量损失并提升电压质量。 阅读建议：重点理解PSO算法在配电网无功优化中的具体应用方式，特别是适应度函数的设计思路、粒子更新规则以及粒子筛除策略等内容。对于实际工程项目而言，可以借鉴文中提到的技术细节和参数配置，以指导类似场景下的优化工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值