0x26 广搜变形

电路维修 这道题虽然乍一看就会想斜对角的两点之间边权受初始电路的影响要么为0要么为1，但是有一个思考点就是可以通过奇偶性，证明相邻的两个点是不可能在同一个电路中。练习一下双端队列。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
const int dx[]={-,-,,};
const int dy[]={-,,-,};

char ss[][];
int xx[],yy[],cc[][];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=;i<=n;i++)scanf("%s",ss[i]+);

        memset(cc,-,sizeof(cc));
        xx[n*m+]=,yy[n*m+]=;cc[][]=;
        int head=n*m+,tail=n*m+;bool bk=false;
        while(head<=tail)
        {
            int x=xx[head],y=yy[head];head++;
            if(x==n+&&y==m+){printf("%d\n",cc[x][y]);bk=true;break;}
            for(int k=;k<=;k++)
            {
                int tx=x+dx[k],ty=y+dy[k];
                if(<tx&&tx<=n+&&<ty&&ty<=m+&&(cc[tx][ty]==-||cc[tx][ty]>cc[x][y]))
                {
                    int g=(!((x>tx)^(y>ty)))?((!(ss[min(x,tx)][min(y,ty)]=='/'))?:):((ss[min(x,tx)][min(y,ty)]=='/')?:);
                    if(g==)
                    {
                        head--;
                        xx[head]=tx,yy[head]=ty,cc[tx][ty]=cc[x][y];
                    }
                    else
                    {
                        tail++;
                        xx[tail]=tx,yy[tail]=ty,cc[tx][ty]=cc[x][y]+;
                    }
                }
            }
        }
        if(bk==false)printf("NO SOLUTION\n");
    }
    return ;
}

电路维修

poj3635 有点尴尬啊我写的堆优化bfs卡不过去。。。去A*那再做吧

upd:这算哪门子A*啊，真是被discuss的水逼坑死。。。我写了个用路径中最小价格的加油站*油数做预估函数的A*跑的比堆+bfs还慢，结果就是正解就是判断是否之前已经走过更短的（对没错就像最短路那样），剪枝一下就过了？？？（思维僵化啊菜鸡yzh）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;

int n,m,c[];
struct edge
{
    int x,y,d,next;
}a[];int len,last[];
void ins(int x,int y,int d)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].d=d;
    a[len].next=last[x];last[x]=len;
}

int C,st,ed;
struct Astar
{
    int x,l,s;
    friend bool operator>(Astar n1,Astar n2){return n1.s>n2.s;}
};priority_queue<Astar,vector<Astar>,greater<Astar> >q;
int g[][];
void bfs()
{
    memset(g,,sizeof(g));g[st][]=;
    while(!q.empty())q.pop();
    Astar t;
    t.x=st, t.l=, t.s=, q.push(t);
    while(!q.empty())
    {
        Astar tno=q.top();q.pop();
        if(tno.x==ed)
        {
            printf("%d\n",tno.s);
            return ;
        }
        if(tno.l+<=C&&g[tno.x][tno.l+]>g[tno.x][tno.l]+c[tno.x])
        {
            g[tno.x][tno.l+]=g[tno.x][tno.l]+c[tno.x];
            t.x=tno.x, t.l=tno.l+, t.s=tno.s+c[t.x], q.push(t);
        }
        for(int k=last[tno.x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(tno.l>=a[k].d&&g[y][tno.l-a[k].d]>g[tno.x][tno.l])
            {
                g[y][tno.l-a[k].d]=g[tno.x][tno.l];
                t.x=y, t.l=tno.l-a[k].d, t.s=tno.s, q.push(t);
            }
        }
    }
    printf("impossible\n");
}

int main()
{
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++)scanf("%d",&c[i]);
    for(int i=;i<=m;i++)
    {
        int x,y,d;
        scanf("%d%d%d",&x,&y,&d);x++,y++;
        ins(x,y,d);ins(y,x,d);
    }
    int Q;
    scanf("%d",&Q);
    while(Q--)
    {
        scanf("%d%d%d",&C,&st,&ed);st++,ed++;
        bfs();
    }
    return ;
}

poj3635

hdoj3085 这题真是折腾死了。。。题意有点不清（去找discuss）做法是两个轮流走并且枚举时间层数判断，因为有可能某人（几乎是明明）对于当前时间能够到达的点比另一个多得多。恶心的是这个明明同学一秒三步非常难判，一开始我是写了个三步的方向，结果发现这样会穿墙，然后改成三个走一步套在一起，结果发现拓展的时候，当前秒走了1步和2/3步的拓展是有差异的，但是秒数一样就体现不出来，最后解决的方法就是以1/3秒为单位走，圆满解决

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
const int dx[]={,-,,};
const int dy[]={-,,,};

int n,m,gx1,gy1,gx2,gy2;
char ss[][];
struct node
{
    int x,y,c;
}list[][];
int d[][][];
bool check(int x,int y,int asd){return <x&&x<=n&&<y&&y<=m&&d[asd][x][y]==-&&ss[x][y]!='X';}
int getdis(int x,int y){return min(abs(gx1-x)+abs(gy1-y),abs(gx2-x)+abs(gy2-y));}
int main()
{
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int gx,gy,bx,by,x,y;gx1=-;
        scanf("%d%d",&n,&m);
        for(int i=;i<=n;i++)
        {
            scanf("%s",ss[i]+);
            for(int j=;j<=m;j++)
                     if(ss[i][j]=='M')bx=i,by=j;
                else if(ss[i][j]=='G')gx=i,gy=j;
                else if(ss[i][j]=='Z')
                {
                    if(gx1==-)gx1=i,gy1=j;
                    else       gx2=i,gy2=j;
                }
        }

        int head[],tail[],dep=; bool bk=false;
        head[]=, tail[]=, list[][].x=bx, list[][].y=by;
        head[]=, tail[]=, list[][].x=gx, list[][].y=gy;
        memset(d,-,sizeof(d)); d[][bx][by]=, d[][gx][gy]=;
        if(getdis(bx,by)<=||getdis(gx,gy)<=){printf("-1\n");continue;}

        while(head[]<tail[]&&head[]<tail[])
        {
            while(d[][list[][head[]].x][list[][head[]].y]==dep)
            {
                x=list[][head[]].x,y=list[][head[]].y;
                if(d[][x][y]!=-&&d[][x][y]!=-)
                {
                    printf("%d\n",max(d[][x][y]%==?d[][x][y]/:d[][x][y]/+,d[][x][y]/));
                    bk=true;break;
                }
                if(getdis(x,y)>*(d[][x][y]/+))
                {
                    for(int k=;k<=;k++)
                    {
                        int tx=x+dx[k],ty=y+dy[k];
                        if(check(tx,ty,)&&getdis(tx,ty)>*(d[][x][y]/+))
                        {
                               d[][tx][ty]=d[][x][y]+;
                            list[][tail[]].x=tx, list[][tail[]].y=ty;
                            tail[]++;
                        }
                    }
                }
                head[]++;
            }
            if(bk==true)break;

            while(d[][list[][head[]].x][list[][head[]].y]==dep)
            {
                x=list[][head[]].x,y=list[][head[]].y;
                if(d[][x][y]!=-&&d[][x][y]!=-)
                {
                    printf("%d\n",max(d[][x][y]%==?d[][x][y]/:d[][x][y]/+,d[][x][y]/));
                    bk=true;break;
                }
                if(getdis(x,y)>*(d[][x][y]/+))
                {
                    for(int k=;k<=;k++)
                    {
                        int tx=x+dx[k],ty=y+dy[k],dis=getdis(tx,ty);
                        if(check(tx,ty,)&&dis>*((d[][x][y]+)/))
                        {
                            d[][tx][ty]=d[][x][y]+;
                            list[][tail[]].x=tx, list[][tail[]].y=ty;
                            tail[]++;
                        }
                    }
                }
                head[]++;
            }
            if(bk==true)break;

            dep++;
        }

    /*    for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
                printf("%d ",d[0][i][j]==-1?9:d[0][i][j]);
            printf("\n");
        }
        printf("\n");
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
                printf("%d ",d[1][i][j]==-1?9:d[1][i][j]);
            printf("\n");
        }*/
        if(bk==false)printf("-1\n");
    }
    return ;
}

hdoj3085

宽搜还是比深搜玩的好一些，但是比较复杂的题细节处理的不好