XDU1202(西电17年校赛F题)题解&关于spfa与dijstra+priority_queue的思考

最新推荐文章于 2019-12-19 23:34:32 发布
原创 最新推荐文章于 2019-12-19 23:34:32 发布 · 273 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
探讨了在包含特殊传送区域的矩阵中寻找从起点到终点最短路径的方法。作者经历了从SPFA算法到Dijkstra算法的转变，并最终解决了问题。

题意

链接
给出一个矩阵，从起点到终点，可以一步步走过去，也可以在有命运石大门的区域选择使用steins:gate传送，求最短路径

笺释

这道题来来回回写了十几个版本，在xdoj上提交了不下20次，真是辛苦评测机了。
一开始其实想偏了，考虑到可以传送可以走路，以为类似于守望者的逃离，将传送与走路分开处理再合并。但是实际实现过程中发现可以处理出来只传送的情况，可以处理出来只走路的情况，但是合并的话，一部分走路，一部分传送这个状态很难表示。守望者的逃离之所以可以分开处理是因为她可以贪心选择能传送就一定传送，不会像这道题一样遇到难以合并的情况
然后就考虑用最直接的spfa算法求最短路了，从队列里拿到一个点就考虑从它向四个方向行走能到达的点，从他使用传送门能到达的点，然后这个算法tle了。
接着考虑能不能预处理出来从一个点用传送门能到达的点，这样就不用每拿到一个点都搜索有哪些传送门可用，直接将用传送门和走路抽象成等同的移动方式，每次拿到一个点之后遍历所有能到达的点。
这样遇到的问题就是开不出来这么大的数组表示任意两个点之间的距离，最大要开100*100*100*100=1e9个int，当然会mle，然后想到了可以用vector只处理能到达的两个点之间的距离，如果有多种方式能够到达的话取最小距离，但是最小距离的更新又成了问题，我们通过一种移动方式从A点到B点，想知道之前有没有标记过A点到B点，如果标记过就更新距离为最小值，如果没标记过就加入A点到B点，但是这个过程朴素的思路要查找之前有没有到过，这样以来复杂度会升高很多。于是想到用key数组标记之前有没有到过，如果到过就记录key中的数值表示之前存在了哪个下标。但是key本身又需要100*100*100*100的空间，这时候想到将key仅设置为2维数组记录当前已确定的起点A到其余点B的更新情况，每拿到一个新点A可以循环利用key数组，就只需要100*100的空间了。
后来跟zxy大佬讨论的时候发现这个预处理的过程其实华而不实，并不能降低spfa的很多复杂度，反而自身实现起来相当困难。

void makemaps()
{
        for(int x1=1;x1<=n;x1++)
        {
            for(int y1=1;y1<=m;y1++)
            {
                memset(key,-1,sizeof(key));
                for(int i=1;i<=r;i++)
                {
                    int ax=doors[i].ax;
                    int ay=doors[i].ay;
                    int by=doors[i].by;
                    int bx=doors[i].bx;
                    int t=doors[i].t;
                    int p=doors[i].p;
                    if(!(x1>=ax&&x1<=bx&&y1>=ay&&y1<=by))
                    {
                        continue;
                    }
                for(int x2=ax;x2<=bx;x2++)
                {
                    for(int y2=ay;y2<=by;y2++)
                    {
                        if(x1==x2&&y1==y2)
                        {
                            continue;
                        }
                        if(abs(h[x1][y1]-h[x2][y2])<=p)
                        {
                                if(key[x2][y2]!=-1)
                                {
                                    G[x1][y1][key[x2][y2]].w=min(t,G[x1][y1][key[x2][y2]].w);
                                }
                                else
                                {
                                    G[x1][y1].push_back((edge){x2,y2,t});
                                    key[x2][y2]=G[x1][y1].size()-1;
                                }
                        }
                    }
                }
            }
            for(int k=1;k<=4;k++)
            {
                int x2=x1+movx[k];
                int y2=y1+movy[k];
                if(!legal(x2,y2))
                {
                    continue;
                }
                int nw=h[x1][x1]+h[x2][y2];
                if(key[x2][y2]!=-1)
                {
                    G[x1][y1][key[x2][y2]].w=min(h[x1][y1]+h[x2][y2],G[x1][y1][key[x2][y2]].w);
                }
                else
                {
                    G[x1][y1].push_back((edge){x2,y2,h[x1][y1]+h[x2][y2]});
                    key[x2][y2]=G[x1][y1].size()-1;
                }
            }
        }
    }
}

所以spfa也是tle。
有种逃脱不了命运之手的感觉呢。
然后zxy提供了dijstra+priority_queue的思路，看了一下对于稠密图来说dijstra+queue会比spfa快上不少，于是学习了一下dijstra的基本思想。
dijstra的基本操作是

dis[i]表示从起点到i点的最小距离，然后一开始把起点放入优先队列P，这时候从起点到起点的最短距离一定是确定的0，也就是说，这个dis[s（起点）]不可能再以之后的任何形式完成更新。于是我们可以利用s点更新(松弛)从s点能到达的点。对于从起点更新到的其他点A1,A2,A3,A4并不一定是最短距离，这时候对从起点到他们的距离是一个暂时值T，这时候我们从这些已有暂时值T的点A1,A2,A3,A4中选取一个最小的B，那么从起点到B的最短距离T就由暂时值变成了确定值，这个变化可以这样疏解:**从起点S到B点如不通过这种方式(当前更新时所使用的)到达，那么就一定要使用其他方式到达，而使用其他方式到达B之外的点C的距离一定大于直接到达点B的（直接到达点B已经是目前最小值），更何况从C到B也需要一段距离。**我认为这是一种很精髓的dp思想，利用这个思想就可以逐渐更新起点到所有点的最小值。

关于priority_queue优化的dijstra，还有这么一点值得注意:一个点A在没出队之前是可以多次进队的，但是当他出队之后，起点到他的最短距离就由暂时的不确定值变为了确定值，他不可能再次进队，队中可能有之前对此进入的多个点A，这些点A在读到的时候直接continue。
然后用dijstra+priority_queue写了之后发现还是不能过，我以为是因为我采用的记录更新方式是二维的，也就是说我直接利用矩阵中的原始坐标x，y作为(区分出)(specialize)一个点与其他点的依据，而zxy采用的是将所有点按照x*m+y分配一个编号，他的所有数据结构都是一维的，而我的都是二维的，如果一维和二维有速度上的差异，可能会导致tle。
然后把自己的二维改成了一维抽象点记录，发现还是tle，最后一句句地对拍发现有一处问题。

                    if(dis[nx][ny]>(dis[tx][ty]+t)&&(abs(h[tx][ty]-h[nx][ny])<=pp))
                    {
                        dis[nx][ny]=dis[tx][ty]+t;
                        p.push((node){nx,ny,dis[nx][ny]});
                    }

这个语句块的意思是如果两个点能通过门到达(海拔相差小于pp)且能松弛成功，则松弛。
我之前写成

                if(abs(h[tx][ty]-h[nx][ny])<=pp)
                {
                    if(dis[nx][ny]>(dis[tx][ty]+t)）
                    {
                        dis[nx][ny]=dis[tx][ty]+t;
                        p.push((node){nx,ny,dis[nx][ny]});
                    }
                }

将这一句改成上面的写法之后就AC了，大概是因为第一个dis[nx][ny]的条件是更难满足的，通过这一点做了一个有效的剪枝吧。
这样改了之后二维的写法也勉强跑完了。

完整代码

//一维写法
#include<bits/stdc++.h>
#define MAXN 105
#define INF 0x3f3f3f3f
using namespace std;
int n,m,r,sx,sy,ox,oy,t;
int h[MAXN][MAXN];
int done[MAXN*MAXN];
int dis[MAXN*MAXN];
struct door
{
    int ax,ay,bx,by,t,p;
}doors[11];
struct node
{
    long long to,h;
    bool operator<(const node &A) const
    {
        return h>A.h;
    }
};
vector<node>G[MAXN*MAXN];
void dijstra()
{
    priority_queue<node>p;
    memset(done,0,sizeof(done));
    memset(dis,0x3f,sizeof(dis));
    p.push((node){sx*m+sy,0});
    dis[sx*m+sy]=0;
    while(!p.empty())
    {
        node newnode=p.top();
        p.pop();
        int to=newnode.to;
        int imp=newnode.h;
        if(done[to])
        {
            continue;
        }
        done[to]=1;
   //     printf("%d %d\n",tx,ty);
        for(int i=1;i<=r;i++)
        {
        if(((to/m)>=doors[i].ax&&(to/m)<=doors[i].bx&&(to%m)>=doors[i].ay&&(to%m)<=doors[i].by))
        {

        for(int nx=doors[i].ax;nx<=doors[i].bx;nx++)
        {
            for(int ny=doors[i].ay;ny<=doors[i].by;ny++)
            {
                    if(dis[nx*m+ny]>dis[to]+doors[i].t&&abs(h[to/m][to%m]-h[nx][ny])<=doors[i].p)
                    {
                        dis[nx*m+ny]=dis[to]+doors[i].t;
                        p.push((node){nx*m+ny,dis[nx*m+ny]});
                    }
                }
            }
        }
        }
        for(int i=0;i<G[to].size();i++)
        {
            int cx=G[to][i].to;
            int w=G[to][i].h;
            if(dis[cx]>imp+w)
            {
                dis[cx]=imp+w;
                p.push((node){cx,dis[cx]});
            }
        }
    }
}
int main()
{
    //freopen("c:\\output1.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d %d",&n,&m,&r);
        for(int i=1;i<=n*m+m+1;i++)
        {
            G[i].clear();
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&h[i][j]);
            }
        }
        for(int i=1;i<=r;i++)
        {
            scanf("%d %d %d %d %d %d",&doors[i].ax,&doors[i].ay,&doors[i].bx,&doors[i].by,&doors[i].t,&doors[i].p);
        }
        scanf("%d %d %d %d",&sx,&sy,&ox,&oy);
        for(int x=1;x<=n;x++)
        {
            for(int y=1;y<=m;y++)
            {
                if(y+1<=m)
                {
                    G[x*m+y].push_back(node{x*m+y+1,h[x][y]+h[x][y+1]});
                    G[x*m+y+1].push_back(node{(x)*m+y,h[x][y]+h[x][y+1]});
                }
                if(x+1<=n)
                {
                    G[x*m+y].push_back(node{(x+1)*m+y,h[x][y]+h[x+1][y]});
                    G[(x+1)*m+y].push_back(node{(x)*m+y,h[x][y]+h[x+1][y]});
                }
            }
        }
        dijstra();
        printf("%d\n",dis[ox*m+oy]);
    }
}
//二维写法
#include<bits/stdc++.h>
#define MAXN 101
#define INF 0x3f3f3f3f
using namespace std;
int n,m,r,sx,sy,ox,oy,t;
int h[MAXN][MAXN];
int done[MAXN][MAXN];
int dis[MAXN][MAXN];
int movx[5]={0,-1,1,0,0};
int movy[5]={0,0,0,-1,1};
struct door
{
    int ax,ay,bx,by,t,p;
}doors[11];
struct node
{
    int x,y,h;
    bool operator<(const node &A) const
    {
        return h>A.h;
    }
};
struct edge
{
    int x,y,w;
};
vector<edge>G[MAXN][MAXN];
bool legal(int x,int y)
{
    if(!(x>=1&&x<=n))
    {
        return false;
    }
    if(!(y>=1&&y<=m))
    {
        return false;
    }
    return true;
}
void makemaps()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            for(int k=1;k<=4;k++)
            {
                int nx=i+movx[k];
                int ny=j+movy[k];
                if(!legal(nx,ny))
                {
                    continue;
                }
                G[i][j].push_back((edge){nx,ny,h[i][j]+h[nx][ny]});
            }
        }
    }
}
void dijstra()
{
    priority_queue<node>p;
    memset(done,0,sizeof(done));
    memset(dis,0x3f,sizeof(dis));
    p.push((node){sx,sy,0});
    dis[sx][sy]=0;
    while(!p.empty())
    {
        node newnode=p.top();
        p.pop();
        int tx=newnode.x;
        int ty=newnode.y;
        if(done[tx][ty])
        {
            continue;
        }
        done[tx][ty]=1;
   //     printf("%d %d\n",tx,ty);
        for(int i=1;i<=r;i++)
        {
        int ax=doors[i].ax;
        int ay=doors[i].ay;
        int by=doors[i].by;
        int bx=doors[i].bx;
        int t=doors[i].t;
        int pp=doors[i].p;
        if(!(tx>=ax&&tx<=bx&&ty>=ay&&ty<=by))
        {
            continue;
        }
        for(int nx=ax;nx<=bx;nx++)
        {
            for(int ny=ay;ny<=by;ny++)
            {
                    if(dis[nx][ny]>(dis[tx][ty]+t)&&(abs(h[tx][ty]-h[nx][ny])<=pp))
                    {
                        dis[nx][ny]=dis[tx][ty]+t;
                        p.push((node){nx,ny,dis[nx][ny]});
                    }
                }
            }
        }
        for(int i=0;i<G[tx][ty].size();i++)
        {
            int nx=G[tx][ty][i].x;
            int ny=G[tx][ty][i].y;
            int w=G[tx][ty][i].w;
            if(dis[nx][ny]>dis[tx][ty]+w)
            {
                dis[nx][ny]=dis[tx][ty]+w;
                p.push((node){nx,ny,dis[nx][ny]});
            }
        }
    }
}
int main()
{
    //freopen("c:\\output1.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {

        scanf("%d %d %d",&n,&m,&r);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&h[i][j]);
            }
        }
        for(int i=1;i<=r;i++)
        {
            scanf("%d %d %d %d %d %d",&doors[i].ax,&doors[i].ay,&doors[i].bx,&doors[i].by,&doors[i].t,&doors[i].p);
        }
        scanf("%d %d %d %d",&sx,&sy,&ox,&oy);
        makemaps();
        dijstra();
        printf("%d\n",dis[ox][oy]);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                G[i][j].clear();
            }
        }
    }
}
iSikai
关注
算法总结——spfa（使用优先队列的Bellman_Ford算法）
dgjm4087的博客
07-19 274
#include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;functional&gt;//greater 使得从小到大 ，less反 //priority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt; &gt; ...
【模板】SPFA Dijkstra+Heap(priority_queue)
yxr0105
04-30 761
SPFA#include<iostream> #include<cstdio> #include<cstring> #include<queue> using namespace std; const int M=500010; const int N=100010; struct E {int to,nxt,w;}edge[M]; queue<int>q; bool vis[N]; int idx
spfa的玄学优化
smoggyxhdz的博客
05-19 905
  算法提高 道路和航路  时间限制：1.0s   内存限制：256.0MB     问题描述农夫约翰正在针对一个新区域的牛奶配送合同进行研究。他打算分发牛奶到T个城镇（标号为1..T），这些城镇通过R条标号为（1..R）的道路和P条标号为（1..P）的航路相连。每一条公路i或者航路i表示成连接城镇Ai（1&amp;lt;=A_i&amp;lt;=T）和Bi（1&amp;lt;=Bi&amp;lt;=T）代价为Ci。每一条公路...
[面试] BFS、Dijstra、SPFA、Floyd求最短路的比较
wuhuagu_wuhuaguo的博客
11-14 1700
求解方向 算法类型 时间复杂度 BFS 求无权图的单源最短路/求树的层序遍历（循环队列） 暴力搜索 O(V+E)，与边有关。最坏的情况就是这个图是完全图，无向完全图有个公式是E = V*(V-1)/2,V=100,则E=10^4,主要由边决定 Dijstra 求带权图的单源最短路（非负权，不可判断是否回
hdu1546(最短路SPFA+priority_queue)
dooder_daodao的专栏
04-03 1075
http://acm.hdu.edu.cn/showproblem.php?pid=1546简单的最短路问题,不过看起来数据不少,所以用了priority_queue来优化SPFA;好吧,我不得不承认,自己很多时候太不小心了~RE了3次,最后才发现接受输入的w[]数组开小了,从16到32再到52再到108......37559582011-04-03 01:05:02Accepted154631MS440K1826 BC++ㄉ ㄉ#include #include #include #include
XDU_Truth 网络赛热身小结
XDU_Truth的专栏
09-18 991
XDU_Truth 网络赛热身小结 1. 杭电热身赛： http://acm.hust.edu.cn/vjudge/contest/view.action?cid=31751#overview 6道百人水题+用随机算法YY出一道中档题。另外一到50人中档题卡那里了。 RANK83。 2. 2011成都网络赛：http://acm.hust.edu.cn/vjudge/con
XDU1201(西电17年校赛F题)题解
SoniciSika
04-11 488
题意给定一个面积s，求面积s的矩形共有多少种，只要长或宽不同或者矩形网格划分方式不同则视为不同方案笺释一开始是用暴力枚举1-sqrt(s)中的所有因子，对于已枚举得到的因子c和对应因子s/c，将其枚举c和d的所有划分情况ans1和ans2，答案就是ans1*ans2。超时了。 然后想到如果c或者s/c是素数就不用枚举了，将其划分一定是1*c或者c*1两种情况，所以加入了miller-rabin判断
XDU2019校赛现场赛复盘
qq_42397248的博客
12-19 272
A. 不记得了，记得是道签到题，之前菜的连做这道题都花了四十多分钟，整场现场赛就做了这一道题，菜到无法直视 B. qko 的 aaaa + bbbb 题意：给一个4个字符的字符串，一个unsigned int可以用32个字节组成，用这4个字符构成一个unsigned int，则可以用字符串来支持整型的操作，给两个字符串，求出这样编码后两字符串相加得到的数 思路：简单得不能再简单的模拟题...
xdu1068暨2013陕西省赛C题题解
weixin_34081595的博客
05-14 149
xdu1068暨2013陕西省赛C题题解 题意 知道两个数列M和F，每次从M中选择一个人，和从F中选择的一个人配对，结果是Mi*Fj，请问所有配对情况中第k大的情况是多少。 笺释 先对M和F从小到大排序，显然最小的情况是F[1]*M[1]，最大的情况是F[n]*M[m]，在这个区间内二分。 确定答案x时，若x使得所有配对情况中大于x的数目大于等于K的话，就意味着x太小啦，我们就将mid向右移来增大...
最短路优先队列优化spfa
weixin_45842558的博客
11-10 776
最短路优先队列优化spfa 前置：链式前项星存图 链式前项星存图相比一般的vector方法在代码上复杂度更高，但运行速度更快。 struct edge{ int u,v; int w,ne; }ed[maxm]; int head[maxm], cnt, vis[maxm],dis[maxm]; void init() { cnt = 0; for (int i = 0; i &l...
SPFA和BFS的区别
sugarbliss
01-16 1178
SPFA在形式上和BFS非常类似，不同的是BFS中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点松弛过其它的点之后，过了一段时间可能本身被松弛，于是要再次用来松弛其它的点，这样反复迭代下去。 ...
单下料斗小车 SolidWorks.rar
06-17
单下料斗小车 SolidWorks.rar
反吹风布袋除尘器设计图.rar
最新发布
06-17
反吹风布袋除尘器设计图.rar
多功能水下采集机器人SolidWorks 三维.rar
06-17
多功能水下采集机器人SolidWorks 三维.rar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值