Bzoj2965 保护古迹

Time Limit: 20 Sec  Memory Limit: 256 MB
Submit: 366  Solved: 155

Description

　　某校由于历史悠久，校园中有大量的名胜古迹。为了更好地保护这些古迹，学校决定用篱笆将这些古迹围起来。
　　现在已知有p个地点的古迹需要保护。这些古迹可以看做二维平面上的整数点。有n个点可以作为篱笆的端点，这些端点的坐标也为二维平面上的整数。端点用1到n的整数编号。
　　有m对端点之间可以修建篱笆。用(u,v,w)描述一段可以修建的篱笆，表示端点u和端点v之间可以花费w的代价修建一段。篱笆都看做直线段。为了方便设计，这些可以修建的篱笆都是不会相交的（只会在端点处相交）。
　　将一个古迹围起来是指存在一个由篱笆构成的简单多边形，这个古迹在该多边形内部。
　　由于经费问题，学校希望修建篱笆的花费最小。你需要输出将至少1个，2个，…，p个古迹围起来的最小花费。

Input

　　第一行包含三个正整数p,n,m表示古迹的个数，端点个数和可以修建的篱笆条数。
　　接下来p行，每行包含两个整数，表示每个古迹的坐标。
　　接下来n行，每行包含两个整数，表示每个端点的坐标。这些端点按照输入的顺序依次用1到n的整数编号。
　　最后m行，每行包含三个非负整数u,v,w，表示可以在端点u和端点v之间花w的代价修建一段篱笆。

Output

　　输出p行，分别表示将至少1个，2个，…，p个古迹围起来的最小花费。

Sample Input

3 9 15
-2 2
2 1
2 -1
3 0
3 2
1 2
-1 3
-3 3
-2 1
1 0
2 -2
2 -3
1 2 20
1 7 40
1 8 10
1 9 100
2 3 50
3 4 1000
3 7 10
4 5 10
4 6 10
4 7 1000
5 6 10
6 7 1000
7 8 120
7 9 10
8 9 10

Sample Output

30
100
140

HINT

 

　对于100%的数据，n≤100， m≤C(n,2)，p≤10。所有坐标位置的两维绝对值不超过10⁹，u,v不超过n，w不超过10⁶。

　　保证可以修建的篱笆不会经过古迹。保证可以修建的两段篱笆不会在非端点处相交或重合。保证至少存在一种方案可以包围所有古迹。保证n个点互不相同。

 

Source

中国国家队清华集训 2012-2013 第四天

 

数学问题 计算几何 

图论 网络流 最小割

大脑洞题

 

想题十分钟，写题五小时系列。

把给出的图转成对偶图，选权值和最小的边围住古迹就相当于用最小的代价割断古迹所在区块和最外界的联系——可以转化成最小割问题。

所以基本思路就是：求出对偶图，根据原图中的相邻关系在对偶图上连边，权值等于原图上两区块共用边的权值，从源点向要保护的古迹连边，从“最外面”的点向汇点连边，求最小割。

并不能确定要保护哪些古迹，所幸p<=10，可以暴力枚举所有状态。

剩下的问题就是求对偶图了。

将所有的边拆成两条双向边，从一条未遍历的边出发，一路“左转”（找逆时针旋转角度最大的未走过的边走），直到回到自己，这些边圈出来的就是原图上的一个区块。

实现起来神™麻烦，写出了一个大概的框架就无从下手了，然后找了风格最像的popoQQQ大爷的代码开始借鉴模仿,STL和指针什么的各种不会用，自信写完以后无限爆炸。

放弃了探索未知的指针领域，开始换写法照抄，又改了一个多小时，终于不炸了，开始无限WA。

祭出了久违的标准代码比对法，最后发现有一处的网络流加边没加反向弧……

 

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const double pi=acos(-1.0);
const int INF=0x3f3f3f3f;
const int mxn=80010;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m;
namespace Graph{
    struct edge{int v,nxt,f;}e[mxn<<1];
    int hd[mxn],mct=1;
    void add_edge(int u,int v,int w){
        e[++mct].v=v;e[mct].nxt=hd[u];e[mct].f=w; hd[u]=mct;return;
    }
    void insert(int u,int v,int w){
        add_edge(u,v,w);add_edge(v,u,0);return;
    }
    queue<int>q;
    int d[mxn];
    int S,T;
    bool BFS(){
        memset(d,0,sizeof d);
        d[S]=1;
        q.push(S);
        while(!q.empty()){
            int u=q.front();q.pop();
            for(int i=hd[u];i;i=e[i].nxt){
                int v=e[i].v;
                if(e[i].f && !d[v]){
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        return d[T];
    }
    int DFS(int u,int lim){
        if(u==T)return lim;
        int f=0,tmp;
        for(int i=hd[u],v;i;i=e[i].nxt){
            v=e[i].v;
            if(d[v]==d[u]+1 && e[i].f && (tmp=DFS(v,min(lim,e[i].f)))){
                e[i].f-=tmp;  e[i^1].f+=tmp;
                lim-=tmp;   f+=tmp;
                if(!lim)return f;
            }
        }
        d[u]=0;
        return f;
    }
    int Dinic(){
        int res=0;
        while(BFS())res+=DFS(S,0x3f3f3f3f);
        return res;
    }
    void Reset(){
        for(int i=2;i<=mct;i+=2){  
            e[i].f+=e[i^1].f;
            e[i^1].f=0;
        }
        return;
    }  
    void Ban(int x){  
        for(int i=mct-2*x+1;i<=mct;i+=2) e[i].f=0;
        return;
    }
}
//
namespace Geometry{
    struct point{
        double x,y;
        point operator + (point b){return (point){x+b.x,y+b.y};}
        point operator - (point b){return (point){x-b.x,y-b.y};}
        double operator * (point b){return x*b.x+y*b.y;}
        bool operator < (point b)const{
            return x<b.x || (x==b.x && y<b.y);
        }
    }a[mxn],h[mxn];
    typedef point Vector;
    int cnt=0;//对偶图结点 
    double Cross(point a,point b){
        return a.x*b.y-a.y*b.x;
    }
    double dist(point a,point b){
        return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
    }
    struct seg{
        int x,y;
        double len(){return dist(a[x],a[y]);}
    }se[mxn];
    struct Line{
        Line *par;
        int u,v,w;
        double angle;
        int belong;//所属对偶图点 
        bool operator < (Line b)const{//角度按逆时针排序 
            return angle<b.angle;
        }
    };
    bool angcmp(Line *x,Line *y){return x->angle < y->angle;}
    vector<seg>sg;//搜索时保存的路径 
    vector<Line*>ve[mxn];//从每个点出发的边 
    void add_Line(int x,int y,int w){
        Line *tmp1=new Line;
        (*tmp1).u=x;(*tmp1).v=y;(*tmp1).w=w;(*tmp1).belong=0;
        (*tmp1).angle=atan2(a[y].y-a[x].y,a[y].x-a[x].x);
        Line *tmp2=new Line;
        (*tmp2).u=y;(*tmp2).v=x;(*tmp2).w=w;(*tmp2).belong=0;
        (*tmp2).angle=atan2(a[x].y-a[y].y,a[x].x-a[y].x);
        tmp1->par=tmp2;
        tmp2->par=tmp1;
        ve[x].push_back(tmp1);
        ve[y].push_back(tmp2);
        return;
    }
    bool vis[mxn];
    void GDFS(int u,Line *from){//搜对偶图 
//        printf("GDFS:u:%d from.v:%d\n",u,from->v);
        from->belong=cnt;
        sg.push_back((seg){from->par->v,u});//存线段
        vector<Line*>::iterator it;
        it=lower_bound(ve[u].begin(),ve[u].end(),from->par,angcmp);
        it++;
        if(it==ve[u].end())it=ve[u].begin();//顺时针找第一条没经过的边 
        if((*it)->belong)return; 
        GDFS((*it)->v,*it);
        return;
    }
    double calc(){//算面积 
        double res=0;
        vector<seg>::iterator it;
        for(it=sg.begin();it!=sg.end();it++){
            res+=Cross(a[(*it).y],a[(*it).x]);
        }
        return res/2;
    }
    double getangle(point p1,point p2){
        return acos( (p1*p2)/sqrt(p1*p1)/sqrt(p2*p2) );
    }
    bool check(point c){
        static const point v=(point){3.141592653,2.718281828};
        int tmp=0;
        vector<seg>::iterator it;
        point p=c+v;
        for(it=sg.begin();it!=sg.end();it++){
            double C1=Cross(c-a[(*it).x],p-a[(*it).x]);
            double C2=Cross(c-a[(*it).y],p-a[(*it).y]);
            if(C1*C2<0 && getangle(v,a[(*it).x]-c)+getangle(v,a[(*it).y]-c)<=pi )
                tmp++;
        }
        return tmp&1;
    }
}
//
int p;
int inarea[mxn];//古迹所属区域 
double mxarea=0;
int ans[mxn];
int main(){
//    freopen("in.txt","r",stdin);
    using namespace Graph;
    using namespace Geometry;
    int i,j,u,v,w;
    S=0;T=4100;cnt=0;
    p=read();n=read();m=read();
    for(i=1;i<=p;i++){scanf("%lf%lf",&h[i].x,&h[i].y);}
    for(i=1;i<=n;i++){scanf("%lf%lf",&a[i].x,&a[i].y);}
    for(i=1;i<=m;i++){
        u=read();v=read();w=read();
        add_Line(u,v,w);
    }
    for(i=1;i<=n;i++)sort(ve[i].begin(),ve[i].end(),angcmp);
    //
    for(i=1;i<=n;i++){//枚举起点 
        vector<Line*>::iterator it;
        for(it=ve[i].begin();it!=ve[i].end();it++){
            if(!(*it)->belong){
                sg.clear();
                ++cnt;
                GDFS((*it)->v,*it);
                double res=calc();
                if(res<0){
                    insert(cnt,T,INF);
                    continue;
                }
                for(j=1;j<=p;j++){//枚举点判断是否在区间内 
                    if(check(h[j])){
                        inarea[j]=cnt; 
                    }
                }
            }
        }
    }
    //平面图转对偶图
    for(i=1;i<=n;i++){//对偶图相邻点连边 
        vector<Line*>::iterator it;
        for(it=ve[i].begin();it!=ve[i].end();it++){
            insert((*it)->belong,(*it)->par->belong,(*it)->w);
        }
    }
    memset(ans,0x3f,sizeof ans);
    int ed=1<<p;
    for(i=1;i<ed;i++){//枚举要保护的古迹集 
        int num=0;
        for(j=1;j<=p;j++){
            if(i&(1<<(j-1))){
                num++;
                insert(S,inarea[j],INF);
            }
        }
        int res=Dinic();
        ans[num]=min(ans[num],res);
        Reset();
        Ban(num);
    }
    for(i=1;i<=p;i++){
        printf("%d\n",ans[i]);
    }
    return 0;
}