• BZOJ 1001 狼抓兔子


    1001: [BeiJing2006]狼抓兔子

    Time Limit: 15 Sec  Memory Limit: 162 MB
    Submit: 25653  Solved: 6512
    [Submit][Status][Discuss]

    Description

    现在小朋友们最喜欢的"喜羊羊与灰太狼",话说灰太狼抓羊不到,但抓兔子还是比较在行的,
    而且现在的兔子还比较笨,它们只有两个窝,现在你做为狼王,面对下面这样一个网格的地形:

     

    左上角点为(1,1),右下角点为(N,M)(上图中N=4,M=5).有以下三种类型的道路 
    1:(x,y)<==>(x+1,y) 
    2:(x,y)<==>(x,y+1) 
    3:(x,y)<==>(x+1,y+1) 
    道路上的权值表示这条路上最多能够通过的兔子数,道路是无向的. 左上角和右下角为兔子的两个窝,
    开始时所有的兔子都聚集在左上角(1,1)的窝里,现在它们要跑到右下解(N,M)的窝中去,狼王开始伏击
    这些兔子.当然为了保险起见,如果一条道路上最多通过的兔子数为K,狼王需要安排同样数量的K只狼,
    才能完全封锁这条道路,你需要帮助狼王安排一个伏击方案,使得在将兔子一网打尽的前提下,参与的
    狼的数量要最小。因为狼还要去找喜羊羊麻烦.

    Input

    第一行为N,M.表示网格的大小,N,M均小于等于1000.
    接下来分三部分
    第一部分共N行,每行M-1个数,表示横向道路的权值. 
    第二部分共N-1行,每行M个数,表示纵向道路的权值. 
    第三部分共N-1行,每行M-1个数,表示斜向道路的权值. 
    输入文件保证不超过10M

    Output

    输出一个整数,表示参与伏击的狼的最小数量.

    Sample Input

    3 4
    5 6 4
    4 3 1
    7 5 3
    5 6 7 8
    8 7 6 5
    5 5 5
    6 6 6

    Sample Output

    14

    HINT

     2015.4.16新加数据一组,可能会卡掉从前可以过的程序。

    Source

    这道题所有人看的第一眼都会认为这不是一道网络流的水题么

    可是数据范围告诉我们会超时的

    这个图是对称的,兔子过不去就相当于从左下角到右上角把路封死,就像这样

    我们可以从左下角往右上角一次连边

    最后跑最短路即可

    具体实现看代码

    #include <bits/stdc++.h>
    #define ll long long 
    using namespace std;
    inline int read(){
        int x=0;int f=1;char ch=getchar();
        while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
        while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
        return x*f;
    } 
    const int MAXN=2e6+10;
    namespace zhangenming{
        struct node{
            int y,next;
        }e[MAXN<<2];
        int linkk[MAXN<<2],len=0,n,m,sum1,sum2,a[4000010];
        inline void insert(int xx,int yy){
            e[++len].y=yy;e[len].next=linkk[xx];linkk[xx]=len;
        }
        void init(){
            n=read();m=read();
        }
        int q[MAXN],vis[MAXN<<1]={},dis[MAXN<<1],head=0,tail=0;
        void spfa(){
            memset(dis,10,sizeof(dis));
            for(int i=1;i<m;i++){
                int tn=(n-1)*(m-1)+i;
                q[++tail]=tn;dis[tn]=0;vis[tn]=1;
            }
            for(int i=1;i<n;i++){
                int tn=(m-1)*n+(i-1)*m+1;
                q[++tail]=tn;dis[tn]=0;vis[tn]=1;
            }
            int maxn=2000000;
            while(head!=tail){
                if(head==maxn) head=0;
                int tn=q[++head];
                for(int i=linkk[tn];i;i=e[i].next){
                    if(dis[e[i].y]>dis[tn]+a[tn]){
                        dis[e[i].y]=dis[tn]+a[tn];
                        if(!vis[e[i].y]){
                            q[++tail]=e[i].y;
                            if(tail==maxn) tail=0;
                            vis[e[i].y]=1;
                        }
                    }
                } 
                vis[tn]=0;
            }
        }
        inline int heng(int xx,int yy){
            return (xx-1)*(m-1)+yy;
        }
        inline int shu(int xx,int yy){
            return (sum1+(xx-1)*m+yy);
        }
        inline int  xie(int xx,int yy){
            return sum2+(xx-1)*(m-1)+yy;
        }
        void solve(){
            sum1=n*(m-1);
            sum2=sum1+(n-1)*m;
            for(int i=1;i<=n;i++){
                for(int j=1;j<m;j++){
                    int tn=heng(i,j);
                    a[tn]=read();
                }
            }
            for(int i=1;i<n;i++){
                for(int j=1;j<=m;j++){
                    int tn=shu(i,j);
                    a[tn]=read();
                } 
            }
            for(int i=1;i<n;i++){
                for(int j=1;j<m;j++){
                    int tn=xie(i,j);
                    a[tn]=read();
                }
            }
            
            for(int i=1;i<n;i++){
                for(int j=1;j<m;j++){
                    int tn=heng(i,j);int k1=shu(i,j+1);int k2=xie(i,j);
                    insert(k1,tn);insert(k2,tn);
                }
            }
            for(int i=n;i>1;i--){
                for(int j=1;j<m;j++){
                    int tn=heng(i,j);int k1=shu(i-1,j);int k2=xie(i-1,j);
                    insert(tn,k1);insert(tn,k2);
                }
            }
            for(int i=1;i<n;i++){
                for(int j=1;j<m;j++){
                    int tn=xie(i,j);
                    int k1=shu(i,j);int k2=shu(i,j+1);
                    insert(k1,tn);insert(tn,k2);
                }
            }
            spfa();
            int minn=10000000;
            for(int i=1;i<n;i++){
                int tn=shu(i,m);
                minn=min(minn,dis[tn]+a[tn]);
            }
            for(int i=1;i<m;i++){
                int tn=heng(1,i);
                minn=min(minn,dis[tn]+a[tn]);
            }
            cout<<minn<<endl;
        }
    }
    int main(){
        //freopen("All.in","r",stdin);
        //freopen("aa.out","w",stdout);
        using namespace zhangenming;
        init();
        solve();
        return 0;
    }
    

      

  • 相关阅读:
    从B树、B+树、B*树谈到R 树
    1.红黑树和自平衡二叉(查找)树区别 2.红黑树与B树的区别
    红黑树 Java实现
    自平衡二叉(查找树/搜索树/排序树) binary search tree
    从零开始: 二叉查找
    深入理解JAVA虚拟机JVM
    java中的变量各占得字节数
    java中new两个对象,在堆中开辟几个对象空间
    Spring面试,IoC和AOP的理解, @Transactional原理及使用
    EasyUI Tabs + Yii2.0实现iframe方式打开页面(解决共用静态文件引入加载的问题)
  • 原文地址:https://www.cnblogs.com/something-for-nothing/p/7845566.html
Copyright © 2020-2023  润新知