C++博客-From A Start,As An Acmer-随笔分类-教训

CF 159 A [没啥，只是想记录一下自己想的贪心是错的]

BUPT-[aswmtjdsj] @ Penalty — Tue, 27 Mar 2012 05:12:00 GMT

orz。如此一个水题让我想了很久用了无数STL之后已然WA到死。直到想明白自己哪里错了。
哎，自己的贪心果断不靠谱啊。但是为啥他们那些如此暴力的做法都能过呢- -构造卡N^3的数据太难了是么。。

题目大意：
n(int,[1,1000]), d(int,[1,1000])
n条记录，每条记录有a,b(string,len[1,20]),t(int,[0,10000])。按非降序列给出。
a,b,t表示在t时刻，a给b发了一条信息。
约束条件，如果a给b在t1时刻发了信息，且b给a在t2时刻发了信息，且0 < t2 - t1 <= d。那么a和b就是朋友关系。
(不存在自己给自己发消息的情况）

让你给出朋友关系的条数，和每条朋友关系，spj。

我的做法：
错误做法，N*logN的贪心：
逐条读入，用string存unique的string，map存映射。用int[][]存发送时间，abt则rel[index(a)][index(b)] = max(t, rel[index(a)][index(b)]。并与rel[index(b)][index(a)]比较，如果满足约束条件则将(a,b)插入一个set中。
错误关键点：在线更新rel[][]是不对的，虽说两个人的朋友关系与否只和最近一次的两人互通消息有关，但是这中间存在一个反例（由于题目条件的特殊性）：
a b 1
a b 2
b a 2
这组例子a、b是朋友关系。但是由于rel[index(a)][index(b)] = 2 其矩阵对称值也为2，所以不满足约束关系，所以就判错了。
所以一个简单的正确做法为离线做。
正确做法，N^2*logN的枚举：
对于每条记录枚举之前所有记录，看满足约束条件否，满足则扔set。。
（ps，有人用vector代替set都不超时。。。N^3啊，泪目）
（贪心什么的，一证明，二想反例，一定要慎重啊。自己还是太弱了。

太伤了。。。

BUPT-[aswmtjdsj] @ Penalty 2012-03-27 13:12 发表评论

BOJ 1790 Blow up the bridge 【弧扫描】

BUPT-[aswmtjdsj] @ Penalty — Sat, 24 Sep 2011 12:46:00 GMT

链接：http://o.boj.me/onlinejudge/showproblem.php?problem_id=1790
这是我们那年（10年）校赛网络预赛的一道不是很难的题。可是事后我做了一个星期也还是WAWATLETLE。。。
现在想来当年还是太naive了，用了一些乱七八糟甚至不是算法的算法外加了一大堆补丁妄图水过此题。但是事实证明歪门邪道不会带来AC。
经历了那么多以后，虽然我还是蒟蒻，但是好歹掌握了多一点的东西了，于是这题隐约可捉了。

题目大意：
一条线段，N个圆，问这条线段上没被圆覆盖的部分的长度是多少。

做法：
弧扫描。
求出这N个圆与线段所在直线的两个交点（如果有），定一个序，低优先级的为入点，标0，高的为出点，标1；把线段的两个端点标为其他标记，比如2。然后将这最多2*N+2个点排序，按序扫描一遍。
当遇到第一次2且没有遇到第二次2的时候进行统计，初始化in=0，out=0，遇0，in++；遇1，out++；当in==out的时候，加上该点到下一点的距离，而这个就是距离就是未被覆盖的长度的一部分。归纳可知，正确性显然。此即为弧扫描的最简单应用。类似思想出现在poj1981，定长半径圆覆盖最多点问题。
直线方程竟然解错了导致wa了一次，太二了。
x + b * y + c = 0 => b = -(x1-x2)/(y1-y2)!!!!!

犯了错误，我们才会思考；找到不足，我们才能进步。

#include <cstdio>

#include <iostream>

#include <cstring>
#include <cmath>
#include <algorithm>
#define sqr(x) ((x) * (x))
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
#define maxn 1005
int comp(double x)
{
    return fabs(x) < eps?0:x <-eps?-1:1;
}
struct point
{
    double x,y;
    point(){}
    point(double a,double b):x(a),y(b){}
    point operator -(point p)
    {
        return point(x - p.x,y - p.y);
    }
    double norm()
    {
        return sqrt(sqr(x) + sqr(y));
    }
};
struct circle
{
    point c;
    double r;
    circle(){}
    circle(point _c,double _r):c(_c),r(_r){}
}c[maxn];
struct line
{
    point p,q;
    double a,b,c;
    line(){}
    line(point _p,point _q):p(_p),q(_q)
    {
        if(comp(p.x - q.x) == 0)
        {
            a = 1.0;
            b = 0.0;
            c = -p.x;
        }
        else if(comp(p.y - q.y) == 0)
        {
            a = 0.0;
            b = 1.0;
            c = -p.y;
        }
        else
        {
            a = 1.0;
            b = -(p.x - q.x) / (p.y - q.y);
            c = -(b * p.y + p.x);
        }
    }
}L;
struct sol
{
    point p;
    int flag;
    sol(){}
    sol(point _p,int _f):p(_p),flag(_f){}
}s[maxn * 2];
bool operator <(const point a,const point b)
{
    return comp(a.x - b.x) < 0 || (comp(a.x - b.x) == 0 && comp(a.y - b.y) < 0);
}
bool operator <(const sol &a,const sol &b)
{
    return a.p < b.p;
}
int n;
void calc(circle o,point &p,point &q)
{
    double A,B,C,det;
    if(comp(L.a) == 0)
    {
        A = sqr(L.a) + sqr(L.b);
        B = 2.0 * L.a * (L.c + L.b * o.c.y) - 2.0 * sqr(L.b) * o.c.x;
        C = sqr(L.c + L.b * o.c.y) + sqr(L.b) * (sqr(o.c.x) - sqr(o.r));
        det = sqr(B) - 4.0 * A * C;
        if(comp(det) < 0)
            p = q = L.p;
        else
        {
            if(comp(det) == 0)
                det = 0.0;
            p.x = (-B + sqrt(det))/(2.0 * A);
            q.x = (-B - sqrt(det))/(2.0 * A);
            p.y = -(L.a * p.x + L.c) / L.b;
            q.y = -(L.a * q.x + L.c) / L.b;
            if(q < p)
                swap(p,q);
        }
    }
    else
    {
        A = sqr(L.a) + sqr(L.b);
        B = 2.0 * (L.b * L.c + L.a * L.b * o.c.x - sqr(L.a) * o.c.y);
        C = sqr(L.c + L.a * o.c.x) + sqr(L.a) * (sqr(o.c.y) - sqr(o.r));
        det = sqr(B) - 4.0 * A * C;
        if(comp(det) < 0)
            p = q = L.p;
        else
        {
            if(comp(det) == 0)
                det = 0.0;
            p.y = (-B + sqrt(det)) / (2.0 * A);
            q.y = (-B - sqrt(det)) / (2.0 * A);
            p.x = -(L.b * p.y + L.c) / L.a;
            q.x = -(L.b * q.y + L.c) / L.a;
            if(q < p)
                swap(p,q);
        }
    }
}
int main()
{
    while(scanf("%d",&n) == 1 && n)
    {
        for(int i = 0;i < n;i++)
        {
            double x,y,r;
            scanf("%lf %lf %lf",&x,&y,&r);
            c[i] = circle(point(x,y),r);
        }
        double x1,x2,y1,y2;
        scanf("%lf %lf",&x1,&y1);
        scanf("%lf %lf",&x2,&y2);
        L = line(point(x1,y1),point(x2,y2));
        int cnt = 0;
        s[cnt++] = sol(point(x1,y1),2);
        s[cnt++] = sol(point(x2,y2),2);
        for(int i = 0;i < n;i++)
        {
            point p,q;
            calc(c[i],p,q);
            s[cnt++] = sol(p,0);
            s[cnt++] = sol(q,1);
        }
        sort(s,s + cnt);
        int mark = 0,in = 0,out = 0;
        double ans = 0.0;
        for(int i = 0;i < cnt - 1;i++)
        {
            switch(s[i].flag)
            {
                case 0:
                    in++;
                    break;
                case 1:
                    out++;
                    break;
                case 2:
                    mark++;
                    break;
            }
            if(mark == 1 && in == out)
                ans += (s[i].p - s[i+1].p).norm();
        }
        printf("%.4lf\n",ans);
    }
}

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

HDU 4039【水题，bfs】 & HDU 4033【水二分，WA成sb竟然都过不去】

BUPT-[aswmtjdsj] @ Penalty — Sun, 11 Sep 2011 09:38:00 GMT

09题
这题竟然卡STL，真是sb。不解释。
用map+string映射人名和点，对于每个查询的点bfs，并且记录每个点在bfs中被访问的次数，只要搜索完离当前查询点距离为2的点就break。然后遍历所有人的距离，找出其中恰等于2的点被访问的最多次数，把这些访问次数相同且最多的点都放到一个数组里面，排序再输出就好。
卡就卡在，输出和排序用string就TLE了；然后还没给出总人数，竟然和N不同，RE了一次。唉，反正我觉得卡STL属于有病，哪怕string很慢。

03题
水二分，二分边长就好，判定内角和是否等于2*pi以及判定是否每边都能组成三角形。
但是被精度卡到死。亏着claire大神的二分过了，我的二分给我们队贡献了将近一场比赛的罚时。
数据有误的可能性有待查证。

其他题的solution什么的就不放了，因为不想做了；卡人题比坑题恶心多了。题目的想法有坑属于出题人有水平，数据卡其他做法的精度就属于2B了。不解释。

总罚时一天，伤不起。弱爆了。

附代码吧：09题

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;
#include <map>
#include <algorithm>
#include <queue>
#define maxm 4500
#define maxn 2550
#define inf 20000
struct edge
{
    int p,next;
    edge(){}
    edge(int a,int b):p(a),next(b){}
}e[maxm];
int st[maxn];
int d[maxn+5];
int tot,cnt;
int what[maxn];
int n;
struct stu
{
    char str[20];
}name[maxn],sol[maxn];
bool operator <(stu a,stu b)
{
    return strcmp(a.str,b.str) < 0;
}
void init()
{
    tot = 0;
    memset(st,-1,sizeof(st));
}
void add(int p,int q)
{
    e[tot] = edge(q,st[p]);
    st[p] = tot++;
}
void bfs(int tar)
{
    fill(what,what + cnt + 1,0);
    fill(d,d + cnt + 1,inf);
    queue <int> Q;
    Q.push(tar);
    d[tar] = 0;
    while(!Q.empty())
    {
        int now = Q.front();
        Q.pop();
        if(d[now] == 2)
            break;
        for(int k = st[now];~k;k = e[k].next)
        {
            what[e[k].p] ++;
            if(d[e[k].p] > d[now] + 1)
            {
                d[e[k].p] = d[now] + 1;
                Q.push(e[k].p);
            }
        }
    }
}
void gao()
{
    string a,b,opt;
    int q;
    map <string,int> M;
    cnt = 1;
    scanf("%d %d",&n,&q);
    init();
    for(int i = 0;i < n;i++)
    {
        cin >> a >> b;
        if(M[a] == 0)
        {
            M[a] = cnt++;
            strcpy(name[cnt-1].str,a.c_str());
        }
        if(M[b] == 0)
        {
            M[b] = cnt++;
            strcpy(name[cnt-1].str,b.c_str());
        }
        int u = M[a],v = M[b];
        add(u,v);
        add(v,u);
    }
    for(int i = 0;i < q;i++)
    {
        cin >> opt;
        int want = M[opt];
        bfs(want);
        bool mark = false;
        int mmm = 0;
        for(int j = 1;j < cnt;j++)
        {
            if(d[j] == 2)
            {
                mark = true;
                mmm = max(what[j],mmm);
            }
        }
        if(!mark)
            puts("-");
        else
        {
            int solution = 0;
            for(int j = 1;j < cnt;j++)
                if(d[j] == 2 && mmm == what[j])
                    strcpy(sol[solution++].str,name[j].str);
            sort(sol,sol + solution);
            for(int j = 0;j < solution;j++)
            {
                printf("%s%c",sol[j].str,(j==solution-1?'\n':' '));
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 1;i <= t;i++)
    {
        printf("Case %d:\n",i);
        gao();
    }
}

03题：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>

using namespace std;
int n;
double ans,a[105];
const double pi=acos(-1.0);
const double eps=1e-10;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
int f(double x)
{
    double res=0,a1,a2;
    for (int i=1; i<=n; i++)
    {
        a1=a[i];
        if (i<n) a2=a[i+1]; else a2=a[1];
        if (comp(x - a1 - a2) >= 0) return 1;
        if (comp(x - fabs(a1-a2)) <= 0) return -1;
        res+=acos((a1*a1+a2*a2-x*x)/(2*a1*a2));
    }
    if (fabs(res-pi*2)<1e-8) return 0;
    if (comp(res - pi*2) > 0) return 1; else return -1;
}

double bs(double l,double r)
{
    double mid;
    for (int k=1; k<=200; k++)
    {
        mid=(l+r)/2;
        int t=f(mid);
        if (t==0) return mid;
        if (t>0) r=mid; else l=mid;
    }
    return -1;
}

int main()
{
    int o,i,cas=0;
    double r;
    scanf("%d",&o);
    while (o--)
    {
        scanf("%d",&n);
        r=0;
        for (i=1; i<=n; i++)
        {
            scanf("%lf",&a[i]);
            if (a[i]>r) r=a[i];
        }
        ans=bs(0,r*2);
        if (ans<0) printf("Case %d: impossible\n",++cas);
        else printf("Case %d: %.3lf\n",++cas,ans);
    }
}

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

Ural 1588 Jamaica［平面图最短路？］

BUPT-[aswmtjdsj] @ Penalty — Sat, 20 Aug 2011 17:15:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1588

题目一点也不不像所说的那么神。。。虽然标准的O(N^2 * logN)的算法不会吧。不过O(N^3)的算法还是能过的。

给你平面上N个点(<=300)。两两连边，求生成网络的路径总长，注意在同一直线上的边长不要重复计算。

O(N^2)预处理出每两点间最短路。然后利用类似floyd的想法N^3枚举出需要处理掉的边，即诸如d[i][j] = d[i][k] + d[k][j]的边，统计所有边长的时候不要加入此种d[i][j]的值。
关键点1：用double的坏处就在这了，自带常矬卡精度。随随便便就可以构造出那种三点构成的三角形最大内角近似180度的情况用来卡这种处理方式。
即三点近似共线的情况用于卡这个式子fabs(d[i][j] - d[i][k] - d[k][j]) < eps。。一开始eps=1e-6果断被卡了，处理到1e-9才在题目给出的数据范围(10^4)下可以不被精度所影响。
“精度”啊“精度”！！！
关键点2：平常不注意cout输出流的格式自适应，用的太习惯以致于察觉不到这种最常见的小事。这你妹。我真是个蒟蒻啊。
cout输出流对于大double数如果不iomanip的话是会自动用科学计数法输出的！！！平常用cout输出二分中间结果的时候经常会看到，现在怎么想不到了呢！！！我真是太弱了。。。
所以对于哪怕题目要求最后输出四舍五入后的整数，也不要“cout<
少年啊，要记住，非常习惯的事物的小小细节也许是你不曾注意到的坑你的地方。世界上的事情不要想当然。无论在什么方面。

BUPT-[aswmtjdsj] @ Penalty 2011-08-21 01:15 发表评论

我是个蒟蒻啊。。【构造函数用错了类型伤不起啊】

BUPT-[aswmtjdsj] @ Penalty — Sat, 20 Aug 2011 08:42:00 GMT

最近复习几何题，发现了自己的无数蒟蒻点。。。

随时发日志鞭策自己。

1.用int给double赋值还出现了除法的蒟蒻你伤不起啊。。。你cout的时候输出不来小数难道感觉不出来违和感么？！

2.对于一类几何统计问题，比如最多有多少圆可被覆盖或者之类的情况，统计初始值别设为0，因为如果一旦出现不相交但是“自身也合法”的情况，就果断悲剧了啊。
根据情况设定统计初始值。
蒟蒻伤不起啊伤不起。

BUPT-[aswmtjdsj] @ Penalty 2011-08-20 16:42 发表评论