C++博客-From A Start,As An Acmer-随笔分类-POJ Solution Report

二维 & 三维费马点问题【没有理论研究，只有代码研究】

BUPT-[aswmtjdsj] @ Penalty — Fri, 09 Sep 2011 12:23:00 GMT

模拟退火什么的我只知道一个大概思想，然后会很矬的去实现它。近似算法真心伤不起啊唉。
例题：poj 2420 【二维多边形费马点】， uva 5102 【福州现场赛E题，四边形费马点，有结论，所以模拟退火应该不算正解】， ZOJ 2928 【三维费马点】。

模拟退火神马的就是一个迭代过程，在每次迭代中向所有可能的方向试探，然后选取其中最优的一个作为下一次的迭代起点；为了让迭代能够终止，设定了一个步长，每次迭代之后步长乘以一个小于1的系数来减小步长。
迭代方式是相同的，就是向所有可能的方向试探，再按规则模拟计算结果，比如二维点就是向8个方向试探之后再计算到所有点的距离和，而三维点就是26个方向了。
初始步长作为上界，这个该怎么设定我一直不太清楚，我反正是用最大可能步长作为上界的；初始迭代点，随手设置一个吧，我用的是所有点坐标的算术平均数，也可以用原点之类，但是我觉得无论选择啥点都不能保证绝对的正确性的吧（否则，“图灵奖”。。。）；迭代步长系数，好像我的写法比较矬？导致我必须把系数设到0.993以上才能过题，真是弱爆了；至于精度下界就设为1e-10就好了，反正不要钱，哈。

模拟退火的一大弊端在于，如果进入了某个次优解点的邻域，且此时步长已经很小的话，那很有可能就会陷入这个次优解邻域的漩涡里（俗话说叫掉坑里？好像有专业名词叫鞍点或者涡点什么的？我数学不太好不好意思。。），然后再也跑不出来。所以近似算法毕竟是“近似”算法，想避免掉入坑里，只能去优化写法或者找出答案的某种规律性，来分段或者剪枝迭代什么的。。我是玩不转这个了，如上所述的三题，我加起来交了五六十次了吧？总之是没有找到一组又能ac又快的好参数。唉。
我若爆了。。

附代码吧，以2928题为例：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define maxn 105
const double eps = 1e-12;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
using namespace std;
struct point
{
    double x,y,z;
    point(double a = 0,double b = 0,double c = 0):x(a),y(b),z(c){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y,z - p.z);
    }
    point operator + (const point p)
    {
        return point(x + p.x,y + p.y,z + p.z);
    }
    double norm()
    {
        return sqrt(x * x + y * y + z * z);
    }
    point operator *(double a)
    {
        return point(x * a,y * a,z * a);
    }
}p[maxn],fermat,dir[30];
int n;
int main()
{
    while(scanf("%d",&n) == 1)
    {
        for(int i = 0;i < n;i++)
            scanf("%lf %lf %lf",&p[i].x,&p[i].y,&p[i].z);
        int cnt = 0;
        for(int i=-1;i<=1;i++)
            for(int j=-1;j<=1;j++)
                for(int k = -1;k <= 1;k++)
                    dir[cnt++] = point(i,j,k);
        double step = 100;
        point now,ans;
        double temp = 1e10,calc;
        point sel;
        for(int i = 0;i < n;i++)
            ans = ans + p[i];
        ans = ans * (1.0 / (double)n);
        while(step > eps)
        {
            sel = ans;
            for(int i = 0;i < cnt;i++)
            {
                calc = 0.0;
                now = ans + dir[i] * step;
                for(int idx = 0;idx < n;idx++)
                    calc += (p[idx] - now).norm();
                if(comp(calc - temp) < 0)
                {
                    sel = now;
                    temp = calc;
                }
            }
            ans = sel;
            step *= 0.993;
        }
        printf("%.3f %.3f %.3f\n",ans.x,ans.y,ans.z);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-09 20:23 发表评论

POJ 1815 Friendship 【枚举+最小点割转化为最小边割】

BUPT-[aswmtjdsj] @ Penalty — Thu, 25 Aug 2011 14:48:00 GMT

http://poj.org/problem?id=1815

本身最小割什么的不难。输出解和特殊情况的判断比较恶心。

题意，n个人的两两关系矩阵，如果a认识b，则b认识a，且认识有传递性。给出一个s和一个t，问想让s不认识t，最少需要去掉多少人。
如果有解，输出字典序最小的解。（根据那个式子推出）
注意，解为0和无解是两种情况。
（无解唯一会发生在s与t直接相连的时候，即去掉多少点都不能截断这个流；而解为0的含义是，s和t一开始就是断的，初始流为0）
坑爹啊！！！这题意隐藏的真深啊！！！

最小点割转化为最小边割的一般写法：拆点，将p->p'的容量赋值为点权，此题为1，而源汇不拆或者源汇拆点后容量为正无穷；然后if map[i][j] == true，则连边i'->j，容量正无穷。
初始流一遍最大流。
然后开始枚举拆点/拆边。
按字典序枚举点，如果是源汇则跳过，否则重新建图的时候拆掉该点/该边，重新流，如果流减小，说明该点属于最小字典序割集，加入割集。
所以，对于枚举的每个点，还需要判断一下，是否已存在于割集中，如果已存在于割集中则果断拆掉，否则不拆。
记得每次流完之后，如果流量减小则更新最大流，作为下一次枚举的比较值。
这样最后就求出了最小字典序割集，输出即可；如果割集大小为0则无解。
记得在枚举之前先判断一下是否初始流为0，如果为0则不用流了，答案为0。（有解但无须拆点。）

其实无解的情况唯一会发生在源汇直接相连的时候。所以其实应该特判无解，而不是特判0，就不会wa那么久了。。坑爹啊。。。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 405
#define maxm 50005
const int inf = 100000;
struct edge
{
    int p,next,val;
    edge(){}
    edge(int a,int b,int c):p(a),next(b),val(c){}
}e[maxm];
int tot,n,N,S,T,flow[maxn],pre[maxn],v[maxn],arc[maxn],d[maxn],cnt[maxn],path[maxn];
void init()
{
    tot = 0;
    n = N + N + 1;
    fill(v,v + n + 1,-1);
    fill(cnt,cnt + n + 1,0);
    fill(d,d + n + 1,0);
    cnt[0] = n + 1;
}
void add(int p,int q,int val)
{
    e[tot] = edge(q,v[p],val);
    v[p] = tot++;
    e[tot] = edge(p,v[q],0);
    v[q] = tot++;
}
int mflow()
{
    int sum,now,i,k,least,loc;
    int s = 0,t = n;
    bool flag;
    for(int i = 0;i <= n;i++)
        arc[i] = v[i];
    for(sum = 0,now = inf,i = s;d[s] < n + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i];~k;k = e[k].next)
        {
            if(e[k].val && d[i] == d[e[k].p] + 1)
            {
                now = min(now,e[k].val);
                pre[e[k].p] = i;
                path[e[k].p] = k;
                arc[i] = k;
                i = e[k].p;
                if(i == t)
                {
                    for(sum += now;i != s;i = pre[i])
                    {
                        e[path[i]].val -= now;
                        e[path[i] ^ 1].val += now;
                    }
                    now = inf;
                }
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            for(least = n + 1,k = v[i];~k;k = e[k].next)
            {
                if(e[k].val && d[e[k].p] < least)
                {
                    least = d[e[k].p];
                    loc = k;
                }
            }
            cnt[d[i]]--;
            if(!cnt[d[i]])
                break;
            d[i] = least + 1;
            cnt[d[i]]++;
            arc[i] = loc;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return sum;
}
bool old[maxn][maxn];
int sol[maxn];
int ans;
int main()
{
    while(scanf("%d %d %d",&N,&S,&T) == 3)
    {
        memset(old,0,sizeof(old));
        for(int i = 1;i <= N;i++)
            for(int j = 1;j <= N;j++)
            {
                int opt;
                scanf("%d",&opt);
                if(opt)
                    old[i][j] = 1;
                else
                    old[i][j] = 0;
            }
        ans = 0;
        init();
        add(0,S,inf);
        add(T + N,n,inf);
        for(int i = 1;i <= N;i++)
        {
            if(i == S || i == T)
                add(i,i + N,inf);
            else
                add(i,i + N,1);
        }
        for(int i = 1;i <= N;i++)
            for(int j = 1;j <= N;j++)
                if(old[i][j])
                    add(i+N,j,inf);
        int FLOW = mflow();
        if(FLOW == 0)
        {
            puts("0");
            continue;
        }
        for(int i = 1;i <= N;i++)
        {
            if(i == S || i == T)
                continue;
            init();
            add(0,S,inf);
            add(T + N,n,inf);
            for(int j = 1;j <= N;j++)
            {
                if(j == S || j == T)
                {
                    add(j,j + N,inf);
                    continue;
                }
                if(j == i)
                    continue;
                bool flag = false;
                for(int k = 0;k < ans;k++)
                    if(sol[k] == j)
                    {
                        flag = true;
                        break;
                    }
                if(!flag)
                    add(j,j + N,1);
            }
            for(int j = 1;j <= N;j++)
                for(int k = 1;k <= N;k++)
                    if(old[j][k])
                        add(j + N,k,inf);
            int temp = mflow();
            if(temp < FLOW)
            {
                sol[ans++] = i;
                FLOW = temp;
            }
        }
        if(ans == 0)
            puts("NO ANSWER!");
        else
        {
            printf("%d\n",ans);
            for(int i = 0;i < ans;i++)
                printf("%d%c",sol[i],(i==ans-1?'\n':' '));
        }
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-25 22:48 发表评论

POJ 3189 Steady Cow Assignment ［二分＋枚举＋最大流］

BUPT-[aswmtjdsj] @ Penalty — Thu, 18 Aug 2011 17:11:00 GMT

链接：http://poj.org/problem?id=3189
一开始理解错题意了，以为是使得每个牛棚中的喜好度差值最小。。。这果断是神题吧，O(20^20 * log(20) * O(网络流))的复杂度。坑爹啊。
后来发现是全局（全牛棚）的喜好度差值最小。。那么果断枚举上界＋二分区间长度（即答案）＋网络流流之啊。
对于每种上下界，牛连源，棚连汇，只有符合区间条件的牛和棚才连边。
网络流判断可行性即可。
（貌似二分＋多重匹配是正解？不会多重匹配的蒟蒻飘过。。）

附代码。。。以后真应该把网络流那块写上个
/*
SAP
*/
省得每次写solution report都贴出来。。占字数。。。。我是蒟蒻啊啊啊啊啊啊。。。

#include
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 1025
#define maxm 90000
#define maxb 22
const int inf = ~0u >> 1;
struct edge
{
    int p,next,val;
    edge(){}
    edge(int _p,int _n,int _v):p(_p),next(_n),val(_v){}
}e[maxm];
int flow[maxn],pre[maxn],cnt[maxn],d[maxn],path[maxn],v[maxn],arc[maxn];
int tot,last,n,b;
void init()
{
    last = n + b + 1;
    tot = 0;
    fill(v,v + last + 1,-1);
    fill(cnt,cnt + last + 1,0);
    fill(d,d + last + 1,0);
    cnt[0] = last + 1;
}
void add(int p,int q,int val)
{
    e[tot] = edge(q,v[p],val);
    v[p] = tot++;
    e[tot] = edge(p,v[q],0);
    v[q] = tot++;
}
int mflow()
{
    int s = 0,t = last;
    int now,sum,i,k,least,loc;
    bool flag;
    for(int i = 0;i <= last;i++)
        arc[i] = v[i];
    for(sum = 0,now = inf,i = s;d[s] < last + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i];~k;k = e[k].next)
        {
            if(e[k].val && d[i] == d[e[k].p] + 1)
            {
                now = min(e[k].val,now);
                pre[e[k].p] = i;
                path[e[k].p] = k;
                arc[i] = k;
                i = e[k].p;
                if(i == t)
                {
                    for(sum += now;i != s;i = pre[i])
                    {
                        e[path[i]].val -= now;
                        e[path[i]^1].val += now;
                    }
                    now = inf;
                }
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            for(least = last + 1,k = v[i];~k;k = e[k].next)
            {
                if(e[k].val && d[e[k].p] < least)
                {
                    least = d[e[k].p];
                    loc = k;
                }
            }
            cnt[d[i]]--;
            if(!cnt[d[i]])
                break;
            d[i] = least + 1;
            cnt[d[i]]++;
            arc[i] = loc;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return sum;
}
int cow[maxn][maxb];
int barn[maxb];
void graph(int low,int up)
{
    for(int i = 1;i <= n;i++)
    {
        add(0,i,1);
        for(int j = low;j <= up - 1;j++)
            add(i,cow[i][j] + n,1);
    }
    for(int j = 1;j <= b;j++)
        add(j + n,last,barn[j]);
}
int main()
{
    scanf("%d %d",&n,&b);
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= b;j++)
            scanf("%d",&cow[i][j]);
    for(int i = 1;i <= b;i++)
        scanf("%d",&barn[i]);
    int l = 1,r = b,mid;
    int ans = b;
    while(l < r)
    {
        mid = (l + r) >> 1;
        bool flag = false;
        for(int i = 1;i + mid - 1 <= b;i++)
        {
            init();
            graph(i,i + mid);
            int temp = mflow();
            //cout << temp << " temp " << i << " i " << i + mid - 1 << " j" << endl;
            if(temp == n)
            {
                flag = true;
                break;
            }
        }
        if(flag)
        {
            r = mid;
            if(ans > mid)
                ans = mid;
        }
        else
            l = mid + 1;
    }
    printf("%d\n",ans);
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-19 01:11 发表评论

POJ 1087 A Plug For UNIX［网络流恶心的读入］

BUPT-[aswmtjdsj] @ Penalty — Mon, 15 Aug 2011 16:28:00 GMT

链接：http://poj.org/problem?id=1087
题目大意：
N个插座，M个电器可以插到M种插座上（这M种和前N种不一定重合），K种插头转换器，可以接收A插头，插入B插座。N,M,K小于等于100。

建模很裸，源连物品，汇连已有插座，M种对应关系连有向边，这之前的边容量都为1；K种关系之间连有向边，容量正无穷。流之，输出M-mflow
恶心处在两个地方：N、M、K不是一开始给出，网络流的初始化函数需要更改，很讨厌。
M种可插插座不一定存在于N种已有插座中，下标不好写，果断用map映射string搞起，蛋疼不解释。ps，预存这种事情真的很讨厌。
边数随便写的，数据果然水。建好图之后把有容量边打出来围观一下就知道建图正确与否。
话说读题很坑。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <string>
using namespace std;
const int inf = ~0u >> 1;
#define maxn 305
#define maxm 2000
#define maxl 30
int n,N,M,K;
int tot;
struct edge
{
    int p,val,next;
    edge(){}
    edge(int a,int b,int c):p(a),val(b),next(c){}
}e[maxm];
int flow[maxn],v[maxn],arc[maxn],d[maxn],cnt[maxn],pre[maxn],path[maxn];
void init()
{
    tot = 0;
    memset(d,0,sizeof(d));
    memset(cnt,0,sizeof(cnt));
    memset(v,-1,sizeof(v));
}
int label[maxn];
char pro[maxn];
void add(int p,int q,int val)
{
    e[tot] = edge(q,val,v[p]);
    v[p] = tot++;
    e[tot] = edge(p,0,v[q]);
    v[q] = tot++;
}
int mflow()
{
    cnt[0] = n + 1;
    int s = 0,t = n;
    int sum,now,i,k,least,loc;
    bool flag;
    for(int i = 0;i <= n;i++)arc[i] = v[i];
    for(sum = 0,now = inf,i = s;d[s] < n + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i];~k;k = e[k].next)
        {
            if(e[k].val && d[i] == d[e[k].p] + 1)
            {
                now = min(now,e[k].val);
                pre[e[k].p] = i;
                path[e[k].p] = k;
                arc[i] = k;
                i = e[k].p;
                if(i == t)
                {
                    for(sum += now;i != s;i = pre[i])
                    {
                        e[path[i]].val -= now;
                        e[path[i]^1].val += now;
                    }
                    now = inf;
                }
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            for(least = n + 1,k = v[i];~k;k = e[k].next)
            {
                if(e[k].val && d[e[k].p] < least)
                {
                    loc = k;
                    least = d[e[k].p];
                }
            }
            cnt[d[i]]--;
            if(cnt[d[i]] == 0)
                break;
            d[i] = least + 1;
            cnt[d[i]]++;
            arc[i] = loc;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return sum ;
}
int main()
{
    map <string,int> MAP;
    scanf("%d",&N);
    int cnt = 1;
    memset(pro,0,sizeof(pro));
    string opt,_opt;
    for(int i = 1;i <= N;i++)
    {
        cin >> opt;
        MAP[opt] = cnt;
        pro[cnt++] = 1;//to sink
    }
    scanf("%d",&M);
    init();
    for(int i = 1;i <= M;i++)
    {
        int a,b;
        cin >> opt >> _opt;
        MAP[opt] = cnt;
        a = cnt;
        pro[cnt++] = 2;//to source
        if(MAP[_opt] == 0)
        {
            MAP[_opt] = cnt;
            b = cnt;
            pro[cnt++] = 3;//middle
        }
        else
            b = MAP[_opt];
        add(a,b,1);
    }
    scanf("%d",&K);
    n = N + M + K + 1;
    for(int i = 1;i <= K;i++)
    {
        cin >> opt >> _opt;
        int a = MAP[opt],b = MAP[_opt];
        add(a,b,inf);
    }
    for(int i = 1;i < cnt;i++)
    {
        if(pro[i] == 1)
            add(i,n,1);
        else if(pro[i] == 2)
            add(0,i,1);
    }
    /*for(int i = 0;i <= n;i++)
        for(int j = v[i];~j;j = e[j].next)
        {
            if(e[j].val)
                cout << i << ' ' << e[j].p << ' ' << e[j].val << endl;
        }*/
    printf("%d\n",M - mflow());
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-16 00:28 发表评论

POJ 3436 ACM Computer Factory 【网络流你妹的建图竟然还要输出解集】

BUPT-[aswmtjdsj] @ Penalty — Sat, 06 Aug 2011 11:27:00 GMT

题面略去。附上链接：http://poj.org/problem?id=3436

若A点输出满足B点的输入，则连一条从A点到B点的有向边，容量正无穷；若某点无输入限制，则连源点到该点；若某点无输出限制，则连该点到汇点。
而对于点权，则拆点，赋容量为点权。
最大流之。
恶心的输出解部分，记录有意义的点的连边情况，流完之后判断流量改变以统计解集。（偷懒想统计反边。。发现有问题，估计是蛋疼的下标写错了）

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 105
#define maxm 5500
#define maxnum 2600
#define maxp 15
const int inf = ~0u >> 1;
struct edge
{
    int p,next,val,anti;
    edge(){}
    edge(int _p,int _n,int _v,int _a):p(_p),next(_n),val(_v),anti(_a){}
}e[maxm];
int flow[maxn],pre[maxn],cnt[maxn],d[maxn],v[maxn],path[maxn],arc[maxn];
int tot,P,n,N,Count;
void init()
{
    tot = 0;
    Count = 0;
    fill(v,v + n + 1,-1);
    memset(cnt,0,sizeof(cnt));
    memset(d,0,sizeof(d));
    cnt[0] = n + 1;
}
void add(int p,int q,int val)
{
    e[tot] = edge(q,v[p],val,tot + 1);
    v[p] = tot++;
    e[tot] = edge(p,v[q],0,tot - 1);
    v[q] = tot++;
}
int mflow()
{
    int s = 0,t = n;
    int i,k,loc,least,sum,now;
    bool flag;
    for(int i = 0;i <= n;i++)arc[i] = v[i];
    for(sum = 0,i = s,now = inf;d[s] < n + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i];~k;k = e[k].next)
        {
            if(e[k].val && d[i] == d[e[k].p] + 1)
            {
                now = min(e[k].val,now);
                pre[e[k].p] = i;
                path[e[k].p] = k;
                arc[i] = k;
                i = e[k].p;
                if(i == t)
                {
                    for(sum += now;i != s;i = pre[i])
                    {
                        e[path[i]].val -= now;
                        e[path[i] ^ 1].val += now;
                    }
                    now = inf;
                }
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            for(least = n + 1,k = v[i];~k;k = e[k].next)
            {
                if(e[k].val && d[e[k].p] < least)
                {
                    least = d[e[k].p];
                    loc = k;
                }
            }
            cnt[d[i]]--;
            if(cnt[d[i]] == 0)
                break;
            arc[i] = loc;
            d[i] = least + 1;
            cnt[d[i]]++;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return sum;
}
int line[maxnum],from[maxnum],to[maxnum],cost[maxnum];
int in[maxn][maxp],out[maxn][maxp];
int main()
{
    scanf("%d %d",&P,&N);
    n = 2 * N + 1;
    init();
    for(int i = 1;i <= N;i++)
    {
        int val;
        scanf("%d",&val);
        add(i,i + N,val);
        for(int j = 0;j < P;j++)
            scanf("%d",&in[i][j]);
        for(int j = 0;j < P;j++)
            scanf("%d",&out[i][j]);
    }
    for(int i = 1;i <= N;i++)
    {
        bool flag = true;
        for(int j = 0;j < P;j++)
        {
            if(in[i][j] == 1)
            {
                flag = false;
                break;
            }
        }
        if(flag)
            add(0,i,inf);
        flag = true;
        for(int j = 0;j < P;j++)
        {
            if(out[i][j] == 0)
            {
                flag = false;
                break;
            }
        }
        if(flag)
            add(i + N,n,inf);
    }
    for(int i = 1;i <= N;i++)
    {
        for(int j = 1;j <= N;j++)
        {
            bool flag = true;
            for(int k = 0;k < P;k++)
            {
                if(out[i][k] == in[j][k] || in[j][k] == 2)
                    continue;
                flag = false;
                break;
            }
            if(flag)
            {
                line[Count] = tot;
                cost[Count] = inf;
                add(i + N,j,inf);
                from[Count] = i;
                to[Count++] = j;
            }
        }
    }
    int ans = mflow();
    int md = 0;
    if(ans)
    {
        for(int i = 0;i < Count;i++)
        {
            if(cost[i] - e[line[i]].val)
                md++;
        }
    }
    printf("%d %d\n",ans,md);
    if(!md)
        return 0;
    for(int i = 0;i < Count;i++)
        if(cost[i] - e[line[i]].val)
            printf("%d %d %d\n",from[i],to[i],cost[i] - e[line[i]].val);
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-06 19:27 发表评论

POJ 3020 Antenna Placement 【最大独立集】

BUPT-[aswmtjdsj] @ Penalty — Fri, 05 Aug 2011 05:46:00 GMT

Antenna Placement

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 3760		Accepted: 1831

Description

The Global Aerial Research Centre has been allotted the task of building the fifth generation of mobile phone nets in Sweden. The most striking reason why they got the job, is their discovery of a new, highly noise resistant, antenna. It is called 4DAir, and comes in four types. Each type can only transmit and receive signals in a direction aligned with a (slightly skewed) latitudinal and longitudinal grid, because of the interacting electromagnetic field of the earth. The four types correspond to antennas operating in the directions north, west, south, and east, respectively. Below is an example picture of places of interest, depicted by twelve small rings, and nine 4DAir antennas depicted by ellipses covering them.

Obviously, it is desirable to use as few antennas as possible, but still provide coverage for each place of interest. We model the problem as follows: Let A be a rectangular matrix describing the surface of Sweden, where an entry of A either is a point of interest, which must be covered by at least one antenna, or empty space. Antennas can only be positioned at an entry in A. When an antenna is placed at row r and column c, this entry is considered covered, but also one of the neighbouring entries (c+1,r),(c,r+1),(c-1,r), or (c,r-1), is covered depending on the type chosen for this particular antenna. What is the least number of antennas for which there exists a placement in A such that all points of interest are covered?

Input

On the first row of input is a single positive integer n, specifying the number of scenarios that follow. Each scenario begins with a row containing two positive integers h and w, with 1 <= h <= 40 and 0 < w <= 10. Thereafter is a matrix presented, describing the points of interest in Sweden in the form of h lines, each containing w characters from the set ['*','o']. A '*'-character symbolises a point of interest, whereas a 'o'-character represents open space.

Output

For each scenario, output the minimum number of antennas necessary to cover all '*'-entries in the scenario's matrix, on a row of its own.

Sample Input

2 
7 9 
ooo**oooo 
**oo*ooo* 
o*oo**o** 
ooooooooo 
*******oo 
o*o*oo*oo 
*******oo 
10 1 
* 
* 
* 
o 
* 
* 
* 
* 
* 
*

Sample Output

17 
5

Source

Svenskt Mästerskap i Programmering/Norgesmesterskapet 2001

随便写了个二分图匹配最后竟然凑过去了。。
怎么说呢，二分图的这些性质，或者说图的这些性质在二分图上的体现和统计都好神奇啊。
有向无环图的最小路径覆盖（数）=二分图的最小边覆盖集（数）=二分图的最大独立集（数）=全集-二分图的最小点覆盖集（数）=全集-二分图的最大匹配数
粗略的说明，最大独立集和最大匹配的关系。
假设一开始图中无边，最大独立集=总点数；当每增加一个匹配，图中就少了一个独立集。当达到最大匹配，不能再增，那么当前独立集数目已达到最大，即为最大独立集。反过来说，由最大独立集构建二分图，对应的匹配图就是最大匹配图；反证之，如果匹配可以增加，那么独立集数必将减小，得证。
好难啊二分图。
图中任意相邻的两个点之间可以连边，也即可以构成匹配。求出最大匹配之后，其实就相当于在图中去掉了多少个点，然后用原点数减去最大匹配数就是剩下的点数，也就是需要覆盖的数目，即答案。

总觉得这玩意儿说不清- -二分图、行列二分图（网格图）总有一些很奇妙的性质，尤其是当出现矛盾连边和覆盖问题的时候。用二分图匹配什么的凑凑就能过了。

这题里面相邻的两点连边，题目就抽象为最小边覆盖集问题，用最少边覆盖最多（所有）点的问题。

现在工夫不够深啊，希望等哪天重新回头看，能有一些不一样的想法。

给一个参考链接吧，虽然觉得里面有些东西说得很奇怪：

http://hi.baidu.com/xuhanqiu/blog/item/0fb64fdbc9dc92d2b6fd48f0.html/cmtid/dc8605d460bffecb50da4b30

代码：（求了无向匹配，于是除2）

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
#define maxn 405
#define maxh 42
#define maxw 12
bool in[maxh][maxw];
bool map[maxn][maxn];
bool vis[maxn];
int mac[maxn];
int num[maxh][maxw];
int h,w,n;
bool find(int x)
{
    for(int i = 1;i <= n;i++)
    {
        if(map[x][i] && !vis[i])
        {
            vis[i] = true;
            if(!mac[i] || find(mac[i]))
            {
                mac[i] = x;
                return true;
            }
        }
    }
    return false;
}
void gao()
{
    scanf("%d %d",&h,&w);
    n = h * w;
    int tot = 0;
    for(int i = 1;i <= h;i++)
        for(int j = 1;j <= w;j++)
        {
            char opt;
            scanf(" %c",&opt);
            in[i][j] = (opt == '*')?1:0;
            if(opt == '*')tot++;
            num[i][j] = (i - 1) * w + j;
        }
    memset(map,0,sizeof(map));
    memset(mac,0,sizeof(mac));
    for(int i = 1;i <= h;i++)
        for(int j = 1;j <= w - 1;j++)
            if(in[i][j] && in[i][j + 1])
                map[num[i][j]][num[i][j+1]]=map[num[i][j+1]][num[i][j]]=1;
    for(int j = 1;j <= w;j++)
        for(int i = 1;i <= h - 1;i++)
            if(in[i][j] && in[i + 1][j])
                map[num[i][j]][num[i+1][j]]=map[num[i+1][j]][num[i][j]]=1;
    for(int i = 1;i <= n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(find(i))
            ans++;
    }
    printf("%d\n",tot - ans/2);
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-05 13:46 发表评论

POJ 3308 Paratoopers 【网络流最小点覆盖】

BUPT-[aswmtjdsj] @ Penalty — Wed, 03 Aug 2011 13:46:00 GMT

Paratroopers

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 3582		Accepted: 1104

Description

It is year 2500 A.D. and there is a terrible war between the forces of the Earth and the Mars. Recently, the commanders of the Earth are informed by their spies that the invaders of Mars want to land some paratroopers in the m × n grid yard of one their main weapon factories in order to destroy it. In addition, the spies informed them the row and column of the places in the yard in which each paratrooper will land. Since the paratroopers are very strong and well-organized, even one of them, if survived, can complete the mission and destroy the whole factory. As a result, the defense force of the Earth must kill all of them simultaneously after their landing.

In order to accomplish this task, the defense force wants to utilize some of their most hi-tech laser guns. They can install a gun on a row (resp. column) and by firing this gun all paratroopers landed in this row (resp. column) will die. The cost of installing a gun in the ith row (resp. column) of the grid yard is r_i (resp. c_i ) and the total cost of constructing a system firing all guns simultaneously is equal to the product of their costs. Now, your team as a high rank defense group must select the guns that can kill all paratroopers and yield minimum total cost of constructing the firing system.

Input

Input begins with a number T showing the number of test cases and then, T test cases follow. Each test case begins with a line containing three integers 1 ≤ m ≤ 50 , 1 ≤ n ≤ 50 and 1 ≤ l ≤ 500 showing the number of rows and columns of the yard and the number of paratroopers respectively. After that, a line with m positive real numbers greater or equal to 1.0 comes where the ith number is r_i and then, a line with n positive real numbers greater or equal to 1.0 comes where the ith number is c_i. Finally, l lines come each containing the row and column of a paratrooper.

Output

For each test case, your program must output the minimum total cost of constructing the firing system rounded to four digits after the fraction point.

Sample Input

1 
4 4 5 
2.0 7.0 5.0 2.0 
1.5 2.0 2.0 8.0 
1 1 
2 2 
3 3 
4 4 
1 4

Sample Output

16.0000

Source

Amirkabir University of Technology Local Contest 2006

solution：
如果不考虑题目中选择每排(列)的费用，那么这题就是一个木有任何掩饰的最小点覆盖问题。
那么就从该模型出发，给它加上点权；对于点权，我们的一般手段就是拆点，转化成网络流的最大流最小割问题。显然，如果这题是求最小和的话，那么建图后求最小割即为答案。
但是既然是求积，那么按照传统思路，求积转化为求和的方法就是取对数，log2()之。
最后这就是一个边容量为浮点型的最大流最小割问题，流之，即AC。

注意点：
1.别脑残建错图，源--(inf)--> 行点 --(log2(val))-->行点拆 --inf--> 列点拆 --(log2(val)) --> 列点 --inf-->汇。。。。不解释，建图2了，调了半天莫名其妙的地方，三天没敲代码就是得死人啊，手生必死！！！
另外建图的时候，别以为你建的图，就“必然真实的表达了你的想法”。

2.double精度的问题，据计算，double精度在15～16位左右，那么本题的inf和eps的差距就不能超过15位，否则精度问题会把你WA成sb。
而由于，eps要开到输出小数位数两倍的原则，那么eps在本题中开到1e-8就是很有必要的一件事情，所以相应的inf最多只能开到1e8。
（但其实呢，2倍原则一般针对带有乘除法的浮点型问题，所以本题只开到1e-5或者1e-6亦可）
但注意本题中的另一个性质，取对数，任何数字log2之后就会变得很小（别告诉我你不知道O(logN)的算法有多么快），所以这题的inf开的很小就好，反正很轻易的就能比单次流上限要高。（inf开到1e2都能过，说明poj还比较仁慈，没有添加什么超2^100的数据。。）

3.poj的C++ 和G++的问题。坑爹啊。G++上面输出double要用%f，C++上面用log2会CE，必须蛋疼的用log(val)/log(2.0)，还有就是这个log中的参数必须严格为浮点数，还不能期待int型自动转换过去，唉，又是个CE。。
这题真是CE+WA专题。。全是蛋疼的罚时。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#include <cmath>
#define maxn 210
#define maxm 2000
const double inf = 1e2;
const double eps = 1e-6;
struct edge
{
    int p,next,anti;
    double val;
    edge(){}
    edge(int _p,int _next,double _val,int _anti):p(_p),next(_next),val(_val),anti(_anti){}
}v[maxn],e[maxm],arc[maxn],path[maxn];
int flow[maxn],pre[maxn],d[maxn],cnt[maxn],tot,n,N,M;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
void init()
{
    tot = 0;
    n = 2 * (N + M) + 1;
    for(int i = 0;i <= n;i++)
        v[i].next = -1;
    memset(d,0,sizeof(d));
    memset(cnt,0,sizeof(cnt));
    cnt[0] = n + 1;
}
void add(int p,int q,double val)
{
    e[tot] = edge(q,v[p].next,val,tot + 1);
    v[p].next = tot++;
    e[tot] = edge(p,v[q].next,0,tot - 1);
    v[q].next = tot++;
}
double mflow()
{
    int s = 0,t = n;
    int i,k,least,loc;
    double total,now;
    bool flag;
    for(i = 0;i <= n;i++)arc[i].next = v[i].next;
    for(total = 0,i = s,now = inf;d[s] < n + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i].next;~k;k = e[k].next)
        {
            if(comp(e[k].val) > 0 && d[i] == d[e[k].p] + 1)
            {
                now = min(e[k].val,now);
                pre[e[k].p] = i;
                arc[i].next = k;
                path[e[k].p].next = k;
                i = e[k].p;
                if(i == t)
                {
                    for(total += now;i != s;i = pre[i])
                    {
                        e[path[i].next].val -= now;
                        e[e[path[i].next].anti].val += now;
                    }
                    now = inf;
                }
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            for(least = n + 1,k = v[i].next;~k;k = e[k].next)
            {
                if(comp(e[k].val) > 0 && least > d[e[k].p])
                {
                    loc = k;
                    least = d[e[k].p];
                }
            }
            arc[i].next = loc;
            cnt[d[i]]--;
            if(!cnt[d[i]])
                break;
            d[i] = least + 1;
            cnt[d[i]]++;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return total;
}
void gao()
{
    int l;
    scanf("%d %d %d",&N,&M,&l);
    init();
    for(int i = 1;i <= N;i++)
    {
        double val;
        scanf("%lf",&val);
        add(0,i,inf);
        add(i,i + N,log(val)/log(2.0));
    }
    for(int i = 1;i <= M;i++)
    {
        double val;
        scanf("%lf",&val);
        add(N + N + i,N + N + M + i,log(val)/log(2.0));
        add(N + N + M + i,n,inf);
    }
    for(int i = 0;i < l;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        add(a + N,b + N + N,inf);
    }
    double ans = mflow();
    printf("%.4lf\n",pow(2.0,ans));
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-03 21:46 发表评论

POJ 1422 & HDU 1151 & ZOJ 1525 Air Raid - POJ 2060 & ZOJ 2221 Taxi Cab Scheme【二分图最大匹配 -- 最小路径覆盖】

BUPT-[aswmtjdsj] @ Penalty — Tue, 19 Jul 2011 13:43:00 GMT

摘要: ZOJ Problem Set - 1525 Air Raid Time Limit: 1 Second Memory Limit: 32768 KB Consider a town where all the streets are one-way and each street leads from one ... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-19 21:43 发表评论

HDU 3829 & POJ 3041 & POJ 1325 & POJ 2226 & SPOJ 282【二分图最大匹配根据矛盾建图】【神！最小点覆盖！】

BUPT-[aswmtjdsj] @ Penalty — Mon, 18 Jul 2011 13:48:00 GMT

摘要: Cat VS Dog Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 125536/65536 K (Java/Others) Total Submission(s): 768 Accepted Submission(s): 258 P... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-18 21:48 发表评论

POJ 2289 Jamie's Contact Groups & POJ 2112 Optimal Milking 【网络流 + 二分答案】【另一做法，二分+多重匹配】

BUPT-[aswmtjdsj] @ Penalty — Sat, 09 Jul 2011 08:43:00 GMT

摘要: 两题大意类似。大概，对于N个A类物体和P个B类物体进行匹配，然后每个B类物体可以匹配多个A类物体，但是有限制。求出满足这个限制的最优答案。2112的特点是需要先floyd求出点之间最短距离，限制为匹配中最短路中最长的那一个尽量短；2289的特点是读入很恶心，善用istringstream流，这题的限制是使每个B类物体的最大匹配最小。多重匹配的做法有空再写～题目链接：http://poj.org/p... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-09 16:43 发表评论

POJ 1985 Cow Marathon & HDU 2196 Computer 【简单树形dp - 树的直径】

BUPT-[aswmtjdsj] @ Penalty — Sat, 09 Jul 2011 03:07:00 GMT

摘要: 我蒟蒻啊，对于树形dp的理解还很浅显，先把初步的几道题理解记录一下。dp要找最优子结构，它的状态转移就要有一个序。树上的dp同样，无非是按照树的生长方向或逆方向进行dp。对于所谓根-叶，叶-根，这两个概念还没有特别明确的认识。单就这两道题而言，无非是某节点到其所有后继节点的状态转移。poj1985 是求树的直径。可以随便选择一个点开始进行bfs或者dfs，从而找到离该点最远的那个点（可以证明，... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-09 11:07 发表评论

POJ 3469 Dual Core CPU 【网络流最小割模型】

BUPT-[aswmtjdsj] @ Penalty — Thu, 07 Jul 2011 14:36:00 GMT

Dual Core CPU

Time Limit: 15000MS		Memory Limit: 131072K
Total Submissions: 10183		Accepted: 4247
Case Time Limit: 5000MS

Description

As more and more computers are equipped with dual core CPU, SetagLilb, the Chief Technology Officer of TinySoft Corporation, decided to update their famous product - SWODNIW.

The routine consists of N modules, and each of them should run in a certain core. The costs for all the routines to execute on two cores has been estimated. Let's define them as A_i and B_i. Meanwhile,M pairs of modules need to do some data-exchange. If they are running on the same core, then the cost of this action can be ignored. Otherwise, some extra cost are needed. You should arrange wisely to minimize the total cost.

Input

There are two integers in the first line of input data, N and M (1 ≤ N ≤ 20000, 1 ≤ M ≤ 200000) .
The next N lines, each contains two integer, A_i and B_i.
In the following M lines, each contains three integers: a, b, w. The meaning is that if module a and module b don't execute on the same core, you should pay extra w dollars for the data-exchange between them.

Output

Output only one integer, the minimum total cost.

Sample Input

3 1 1 10 2 10 10 3 2 3 1000

Sample Output

Source

POJ Monthly--2007.11.25, Zhou Dong

solution
先说做法再说想法。
设一个源，一个汇。
将源点与这n个点连n条有向边，容量为其A值；将这n个点与汇点连n条有向边，容量为其B值。
之后再在这n个点中连m条无向边。

再说注意点。每次写网络流都会发现一大堆坑爹点。
1.点数为20000 + 2个。。预定义宏的时候记得加括号。边数为点数 * 4 + M * 4 （无向）。
2.加边注意不要加反。。否则就2了。。。add(a,b,c){e[tot] = edge(b,v[a].next,c,tot + 1);//.....}
3.定义n的时候为最后一个点的下标，即输入的tn+1。于是cnt[0]要初始化为n + 1。距离最大值则为tn+1（n），即判定条件为d[i] < n + 1。

本题的解即为该网络的最小割。
详解：
随口说两句吧。别人建的模和图和咱建的也差不多。只不过我AC的时候完全没想明白是怎么个回事，随便建了个图就过了。不知道那些AC的人是不是有成熟的证明之后才过的。。。
只是觉得这个建图是显然的。
后来想想大概是这么一回事。
边分三种，入边（源到中继点），内边（中继点之间），出边（中继点到汇）。
对于流网络的任意割，每个中继点至少连接有一条割边中的入边或者出边，这对应着每个进程必须选择一个CPU，而如果割中出现了中边，那么就说明这两个中继点对应的进程分属不同的CPU，所以最小割对应着最小花费，yy结果显然。（具体证明请自行，本人蒟蒻，不会。）

#include <iostream>
#include <cstdio>
using namespace std;
#include <cstring>
#define maxn 20005
#define maxm (maxn * 4 + 200005 * 4)
const int inf = ~0u>>1;
struct edge
{
    int p,next,val,anti;
    edge(){}
    edge(int a,int b,int c,int d):p(a),next(b),val(c),anti(d){}
}v[maxn],e[maxm],path[maxn],arc[maxn];
int flow[maxn],pre[maxn],d[maxn],cnt[maxn];
int tot,s,t,n;
void init()
{
    tot = 0;
    for(int i = 0;i <= n;i++)
    {
        v[i].next = -1;
        d[i] = 0;
        cnt[i] = 0;
    }
    cnt[0] = n + 1;
}
void add(int a,int b,int c)
{
    e[tot] = edge(b,v[a].next,c,tot + 1);
    v[a].next = tot++;
    e[tot] = edge(a,v[b].next,0,tot - 1);
    v[b].next = tot++;
}
int maxflow(int s,int t)
{
    int total,i,k,loc,least,now;
    bool flag;
    for(int i = 0;i <= n;i++)
        arc[i].next = v[i].next;
    for(total = 0,i = s,now = inf;d[i] < n + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i].next;~k;k = e[k].next)
        {
            if(e[k].val > 0 && d[i] == d[e[k].p] + 1)
            {
                now = min(e[k].val,now);
                pre[e[k].p] = i;
                path[e[k].p].next = k;
                arc[i].next = k;
                i = e[k].p;
                if(i == t)
                {
                    for(total += now;i != s;i = pre[i])
                    {
                        e[path[i].next].val -= now;
                        e[e[path[i].next].anti].val += now;
                    }
                    now = inf;
                }
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            for(least = n,k = v[i].next;~k;k = e[k].next)
            {
                if(e[k].val && least > d[e[k].p])
                {
                    loc = k;
                    least = d[e[k].p];
                }
            }
            arc[i].next = loc;
            cnt[d[i]]--;
            if(cnt[d[i]] == 0)
                break;
            d[i] = least + 1;
            cnt[d[i]] ++ ;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return total;
}
int main()
{
    int tn,tm;
    scanf("%d %d",&tn,&tm);
    n = tn + 1;
    init();
    for(int i = 1;i <= tn;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        add(0,i,a);
        add(i,n,b);
    }
    for(int i = 0;i < tm;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    printf("%d\n",maxflow(0,n));
}

BUPT-[aswmtjdsj] @ Penalty 2011-07-07 22:36 发表评论

POJ 1981 Circle and Points 【定长圆覆盖最多点问题】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:14:00 GMT

定长圆覆盖最多点问题

问题描述，给出二维平面内N个点的(x,y)坐标，给一固定半径R。求一圆，圆心位置任意，要求尽可能多的覆盖平面点集中的点。输出最多的覆盖点数。

（限制条件，保证无任意两点距离等于2R，即无两点连线恰为直径。亦无任意三点同时在一个半径为R的圆上。）

朴素算法：由限制条件可知，最后目标圆圆心一定可由某两点唯一确定（即目标圆的圆弧上一定恰有两个平面点集中的点）。具体实现：C(N,2)枚举任意两圆，构造可行圆，枚举N个点，判断是否在圆上或者圆内（即是否被覆盖）。复杂度O(N^3)。

（如果过了就算是水过去的吧，没过就怪常数太大。。= =||）

我所知的标准做法：O(n^2*logn)的圆上交点扫描法。

转化为圆上的弧最多被覆盖几次的问题。

直觉可解，圆上某个弧如果被某个圆覆盖过，那么我们把目标圆圆心放在该段弧上时，目标圆一定能把该弧所在圆圆心覆盖（即平面点集中的某点）。

所以，被覆盖次数最多的弧的被覆盖次数即为目标圆（最优）最多能够覆盖的点数。

具体做法：

依旧是C(N,2)枚举任意两点，以BA为例，此时i=1,j=0。

求取BA的极角theta，利用atan2（因变量范围(-pi,pi]）。

为方便极角排序，对于负角要+2pi。

B、A构造的圆交于X1，X4两点，求取X1B与BA的夹角和X4B与AB的夹角（相同）。

Phi ，acos(D/2.0/R)，D=dis(A,B)。

以上可得出两圆交点在当前圆上对于圆心的极角。

为方便极角排序，每个极角均加2pi，使域扩张到[0，4pi]，从而防止了跨0角的出现。

alpha[t].value=theta – phi + 2pi,alpha[t].flag = 1(弧的进入端)

alpha[t+1].value = theta + phi + 2pi,alpha[t+1].flag = false（弧的退出端）。

接下来，对于每个圆上的t（偶数）个极角进行排序，再顺序扫描，动态更新最大值。

for(i,0,t)

if(alpha[i].flag)

sum++

else

sum--

if(sum > ans)

ans = sum

最后输出答案时，输出ans+1即可。（因为要算上弧所在圆自身）

复杂度：O(n *(nlogn + t))=O(n^2*logn)

题目链接：http://poj.org/problem?id=1981
http://boj.me/onlinejudge/showproblem.php?problem_id=1679

#include <iostream>

#include <cstdio>

#include <cmath>

#include <algorithm>

#define Mn 300//平面点集中点数

using namespace std;

const double eps = 1e-9;//精度调高点没跑~

const double pi = acos(-1.0);

#define sqr(x) ((x) * (x))

double R;//定长

struct point

{

    double x,y;

    void read()

    {

       scanf("%lf%lf",&x,&y);

    }

    void print()

    {

       printf("%lf%lf\n",x,y);

    }

    double friend dis(const point &a,const point &b)

    {

       return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));

    }

}p[Mn + 5];

struct alpha

{

    double v;

    bool flag;

    bool friend operator <(const alpha &a,const alpha &b)//排序专用偏序关系

    {

       return a.v < b.v;

    }

}alp[Mn * Mn + 5];//C(N,2)*2的可能交点（可能极角）

void solve(int n)

{

    R = 1.0;//本题内为单位圆

    for(int i = 0;i < n;i++)

       p[i].read();

    int MAX = 0;

    for(int i = 0;i < n;i++)

    {

       int t = 0;

       for(int j = 0;j < n;j++)

       {

           if(i == j)

              continue;

           double theta,phi,D;

           D = dis(p[i],p[j]);

           if(D > 2.0 * R)//距离超界直接秒杀

              continue;

//关键部分

           theta = atan2(p[j].y - p[i].y,p[j].x - p[i].x);

           if(theta < 0)

              theta += 2 * pi;

           phi = acos(D / (2.0 * R));

           alp[t].v = theta - phi + 2 * pi;

           alp[t].flag = true;

           alp[t + 1].v = theta + phi + 2 * pi;

           alp[t + 1].flag = false;

           t += 2;

       }

       sort(alp,alp + t);

       int sum = 0;

       for(int j = 0;j < t;j++)

       {

           if(alp[j].flag)

              sum ++;

           else

              sum --;

           if(sum > MAX)

              MAX = sum;

       }

    }

    printf("%d\n",MAX + 1);

}

int main()

{

    int n;

    while(scanf("%d",&n) == 1 && n)

    {

       solve(n);

    }

}

//欢迎围观，请大神轻拍~~~

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:14 发表评论

ZOJ 2532 Internship && POJ 3204 Ikki's Story I - Road Reconstruction【网络流的性质，最小割中的关键边】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 03:20:00 GMT

摘要: ZOJ Problem Set - 2532 Internship Time Limit: 5 Seconds Memory Limit: 32768 KB CIA headquarter collects data from across the country through its classified network. The... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 11:20 发表评论

C++博客-From A Start,As An Acmer-随笔分类-POJ Solution Report

二维 & 三维费马点问题【没有理论研究，只有代码研究】

POJ 1815 Friendship 【枚举+最小点割转化为最小边割】

POJ 3189 Steady Cow Assignment ［二分＋枚举＋最大流］

POJ 1087 A Plug For UNIX［网络流 恶心的读入］

POJ 3436 ACM Computer Factory 【网络流 你妹的建图 竟然还要输出解集】

POJ 3020 Antenna Placement 【最大独立集】

POJ 3308 Paratoopers 【网络流 最小点覆盖】

POJ 1422 & HDU 1151 & ZOJ 1525 Air Raid - POJ 2060 & ZOJ 2221 Taxi Cab Scheme【二分图最大匹配 -- 最小路径覆盖】

HDU 3829 & POJ 3041 & POJ 1325 & POJ 2226 & SPOJ 282【二分图最大匹配 根据矛盾建图】【神！最小点覆盖！】

POJ 2289 Jamie's Contact Groups & POJ 2112 Optimal Milking 【网络流 + 二分答案】【另一做法，二分+多重匹配】

POJ 1985 Cow Marathon & HDU 2196 Computer 【简单树形dp - 树的直径】

POJ 3469 Dual Core CPU 【网络流 最小割模型】

POJ 1981 Circle and Points 【定长圆覆盖最多点问题】

定长圆覆盖最多点问题

ZOJ 2532 Internship && POJ 3204 Ikki's Story I - Road Reconstruction【网络流的性质，最小割中的关键边】

POJ 1087 A Plug For UNIX［网络流恶心的读入］

POJ 3436 ACM Computer Factory 【网络流你妹的建图竟然还要输出解集】

POJ 3308 Paratoopers 【网络流最小点覆盖】

HDU 3829 & POJ 3041 & POJ 1325 & POJ 2226 & SPOJ 282【二分图最大匹配根据矛盾建图】【神！最小点覆盖！】

POJ 3469 Dual Core CPU 【网络流最小割模型】