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

HDU 2297 Run 【半平面交 or 维护单调性】

BUPT-[aswmtjdsj] @ Penalty — Sat, 05 Nov 2011 13:32:00 GMT

题目大意：
给n个人参加赛跑，给出某一时刻每个人的位置和速度（保证单向，速度恒定，且互不相同，且不为0），问，假如无限跑下去，过程中有可能有多少个不同的人领先过？（如果某一时刻两人同时领先，则都不算）

做法：
画成s-t图的话，很容易得出半平面交的做法，即以y轴和无穷远向这n条射线包围，求得围成的多边形内核上有多少条线段的问题（去掉y轴和无穷远）。
半平面交N^logN的我不会写，于是就用了himdd大神的模板，算法来源zzy大神的论文。
由于最后求得的点集可能有重点问题，需要先sort再unique一下去重。（表示这份代码用到了complex类，unique，distance等stl。。。太orz了）
代码：

#include
#include
#include
#include
#include
#include
using namespace std;
const double inf=1e-10;
const int Max=60010;
typedef complex<double> Point;
inline int dbcmp(double tp){return tp<-inf?-1:tp>inf;}
double operator^(Point a,Point b)
{return imag(conj(a)*b);}
struct Line{
    Point a,b;
    double angle;
    Line(){}
    Line(Point a,Point b):a(a),b(b){angle=arg(a-b);}
};
bool operator<(Line p,Line l){
    return dbcmp(p.angle-l.angle)<0||
        (dbcmp(p.angle-l.angle)==0&&dbcmp(p.b-p.a^l.b-p.a)<0);
}

Point operator*(const Line& u,const Line&v)
{
    Point tp=u.a;
    double fz=u.a-v.a^v.b-v.a;
    double fm=u.a-u.b^v.b-v.a;
    return tp+(u.b-u.a)*fz/fm;
}
bool onleft(Point p,Line u)
{
    return dbcmp(p-u.a^u.b-u.a)<=0;
}
bool uniquecmp(Line u,Line v)
{
    int a = dbcmp(u.angle-v.angle)==0;
    if(a)
        puts("cao");
    return a;
}
bool iter(Point p,Point q)
{
    return dbcmp(real(p) - real(q)) < 0 || (dbcmp(real(p) - real(q)) == 0 && dbcmp(imag(p) - imag(q)) < 0);
}
Point p[Max];
Line l[Max];
int e[Max];//line的下标
int get_kernel(Line *l,int lsz,Point *p )
{
    int eb=0,ee=2,pb=0,pe=1;
    sort(l,l+lsz);
    p[lsz]=p[0];
    lsz=distance(l,unique(l,l+lsz,uniquecmp));
    e[0]=0;e[1]=1;
    p[0]=l[0]*l[1];
    for(int i=2;i        while(pb!=pe&&!onleft(p[pe-1],l[i]))pe--,ee--;
        while(pb!=pe&&!onleft(p[pb],l[i]))pb++,eb++;
        p[pe++]=l[i]*l[e[ee-1]];
        e[ee++]=i;
    }
    while(pb!=pe&&!onleft(p[pe-1],l[e[eb]]))pe--,ee--;
    //这个循环好像是没有用的。。
    while(pb!=pe&&!onleft(p[pb],l[e[ee-1]]))pb++,eb++;
    p[pe++]=l[e[pb]]*l[e[ee-1]];
    int psz=pe-pb;
    for(int i=0;pb!=pe;i++)p[i]=p[pb++];
    return psz;//点的个数
}
bool uniqueccc(Point p,Point q)
{
    return  dbcmp(real(p)-real(q)) == 0 && dbcmp(imag(p)-imag(q))==0;
}
void gao()
{
    int n;int lsz=0;
    scanf("%d",&n);
    double x,y;
    for(int i=0;i    {
        scanf("%lf%lf",&x,&y);
        l[lsz++]=Line(Point(0,x),Point(1,x+y));
    }
    l[lsz++]=Line(Point(0,0),Point(1,0));
    l[lsz++]=Line(Point(1e22,0),Point(1e22,1));
    l[lsz++]=Line(Point(1,1e22),Point(0,1e22));
    l[lsz++]=Line(Point(0,1e22),Point(0,0));
    int psz=get_kernel(l,lsz,p);
    sort(p,p + psz,iter);
    psz = distance(p,unique(p,p + psz,uniqueccc));
    printf("%d\n",psz-2);
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)
        gao();
}

另一个做法：
学自各种大牛的单调栈。
对于所有元素按照p进行从大到小的排序。因为初始时刻p最大的一定是解集元素之一，
所以虚拟一个元素（p与p最大值相同，速度为0），把这个虚拟元素和第一元素压入栈中，作为初始化。
然后对于之后的第i个元素，先判断它是否比所有已出现过的元素v都大，如果不大于，则直接跳过（因为p小，v同，肯定追不上），再之后就比较该元素追上栈顶下一个元素和栈顶元素追上栈顶下一个元素的时间，如果该元素时间短，就弹栈，直到出现>=为止，把该元素入栈。
最后栈中元素减一即为答案。
算法的原理在于，第一个元素肯定可以领先，然后就比较谁能更早的超过曾经领先过的元素，谁也就曾经“真的”领先过。
栈中元素保证了p单调非增，v单调增。维护出来的依旧是一个凸集，和半平面交效果相同。

有一个问题，很值得思考，这个做法对于所有约束条件符号完全相同的线性规划问题，是有通解性的吧？ax + by + c < 0，保证a，b，< 分别同号的情况下。
“维护单调性”。orz这个神想法。
附代码：

#include
#include
#include
#include
using namespace std;
#include
#define maxn 50005
typedef long long ll;
int t,n;
struct node
{
    int p,v;
    node(){}
    node(int _p,int _v):p(_p),v(_v){}
}nn[maxn];
int ss[maxn];
bool operator < (node a,node b){return a.p > b.p || (a.p == b.p && a.v < b.v);}
bool ok(node a,node b,node c)
{
    return (ll) (b.p - c.p) * (ll) (a.v - b.v) <= (ll)(b.p - a.p) * (ll)(c.v-b.v);
}
void gao()
{
    scanf("%d",&n);
    int a,b;
    for(int i = 0;i < n;i++)
    {
        scanf("%d %d",&a,&b);
        nn[i] = node(a,b);
    }
    sort(nn,nn + n);
    int top = 1;
    nn[n] = node(nn[0].p,0);
    ss[0] = n;
    ss[1] = 0;
    int fuck = nn[0].v;
    for(int i = 1;i < n;i++)
    {
        if(nn[i].v < fuck)
            continue;
        fuck = nn[i].v;
        while(top > 0 && ok(nn[ss[top]],nn[ss[top-1]],nn[i]))
            top--;
        ss[++top]=i;
    }
    printf("%d\n",top);
}
int main()
{
    scanf("%d",&t);
    for(int i = 0;i < t;i++)
        gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-11-05 21:32 发表评论

Chengdu Regional 2008［被虐爆了，留个记号］

BUPT-[aswmtjdsj] @ Penalty — Sun, 25 Sep 2011 16:36:00 GMT

摘要: 被打爆了。唉。自己蒟蒻啊。随手写几句。A 暴力竟然可过，worst-case难道不是O(N^2)？B splay，yy半天并查集无果C 区间DP？柯神orz，1YD 扫描线，回头写，我觉得可以做E 矩形交转化成了DP，我弱爆了，想了半天扫描线＋线段树F 神题吧？看得懂题，木有想法G yy了半天费用流神马的，竟然是贪心，蒟蒻啊。H 题都没看I 最短路，建图真恶心J orz claire_大神K 神马... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-09-26 00:36 发表评论

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 发表评论

HDU 4024 Dwarven Sniper’s hunting【水二分】

BUPT-[aswmtjdsj] @ Penalty — Sat, 10 Sep 2011 13:09:00 GMT

这。。。。。这题难道自带“错误题意引导”？？？为啥我就算读对了题意，想对了做法，结果敲的时候又按照错误的想法敲了呢？伤不起。。
其实04题才是本场最水题，但是- -题意太坑爹了。唉。

题意：
二维平面追击。
被追击的人有起始坐标，有一个速度矢量，从开始就一直在走。
追击者有起始坐标，有运动速率，射出的子弹也有一个速率。子弹有一个有效射击半径。
就问，在子弹飞行距离最远的情况下，让总追击时间（被追击者被击中前的运动时间）最短，最远距离是多少，最短时间是多少。（一直搞反了题意。妹的。）
条件保证，1e9的时间内一定有解，被追者速率<追者速率<子弹速率。
第二个条件保证了，时间短的时候打不中的话，将时间拉长就一定能打中。
做法：
由于一定有解，为了让飞行距离最长，那么就让它等于射击半径。
果断二分总时间。
得出被追者当前坐标，算出与追击者起始坐标的距离。以射击半径画圆，判断追击者是在圆内还是圆外。并算出小圆半径（即去除子弹时间的剩余时间乘以追击者的运动速率）。判断两圆状态，相离或相切则l = mid，相交则r=mid。（前者表示打不着还需要继续跑，后者表示打到了但不是最优所以要缩短）。
二分中间的某些状态大概可以表示追击者跑到某个地方停了下来，然后等被追击者跑到指定位置再开始秀枪法；但鉴于最优解一定不需要让追击者有等待时间，所以最后的最优状态一定是相切的。
话说因为不小心用到了除法，所以eps开到1e-6会被卡精度，所以没办法只能1e-8了。。第一次写的时候开到1e-6竟然连样例都有精度差，这。。。

唉，被题意坑啊，自己脑子笨，想不清楚二分啊，我弱爆了。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const double eps = 1e-6;
const double inf = 1e9;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
struct point
{
    double x,y;
    point(){}
    point(double a,double b):x(a),y(b){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y);
    }
    point operator *(const double a)
    {
        return point(x * a,y * a);
    }
    point operator +(const point p)
    {
        return point(x + p.x,y + p.y);
    }
    double norm()
    {
        return sqrt(x * x + y * y);
    }
}p1,p2,L;
double vd,vb,limit;
int main()
{
    while(scanf("%lf %lf %lf %lf %lf %lf %lf %lf %lf",&p1.x,&p1.y,&p2.x,&p2.y,&L.x,&L.y,&vd,&vb,&limit) == 9)
    {
        if(!comp(p1.x) && !comp(p1.y) && !comp(p2.x) && !comp(p2.y) && !comp(L.x) && !comp(L.y) && !comp(vd) && !comp(vb) && !comp(limit))
            break;
        double t2 = limit / vb;
        double l = 0.0,r = inf,mid;
        while(comp(l - r) < 0)
        {
            mid = (l + r) / 2.0;
            point now = p1 + L * mid;
            if(comp(t2 - mid) > 0)
            {
                l = mid;
                continue;
            }
            double d = (now - p2).norm();
            double most = (mid - t2) * vd;
            if(comp(d - limit) <= 0)
            {
                if(comp(d + most - limit) < 0)
                    l = mid;
                else
                    r = mid;
            }
            else
            {
                if(comp(most + limit - d) < 0)
                    l = mid;
                else
                    r = mid;
            }
        }
        printf("%.3lf %.3lf\n",limit,mid);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-10 21:09 发表评论

HDU 4022 Bombing【STL 继续练习】

BUPT-[aswmtjdsj] @ Penalty — Sat, 10 Sep 2011 11:10:00 GMT

今天真是各种sb，弱爆了。
果然以后做网预的时候就应该第一道水题用STL各种水。
闲话少说。
本题题意略，直接说做法。
首先，必需的是离散化。sort+MAP是我的离散化方法，个人觉得这样虽然慢，但是好写。
后面的就八仙过海各显神通了。什么用十字链表模拟啊，什么multiset啊，什么vector啊，什么数组直接标记啊，不一而足，水题就要用水题的方法做。
我是vector做的。
开了200000个vector分别用来存储离散化后的每行及每列中元素的个数。
每次查询的时候，将对应行/或者列的size输出，然后对其中每个元素在另外一边（行/列）用upper/lower_bound查存在性，存在的都删除erase，然后将本行/列清空clear。
一开始就是WA在此处了，因为有重复坐标的点，而set的一般写法无法处理这种情况，想了半天最后用了vector+二分。太蛋疼了。
还RE了一次，因为对于vector来说，erase作为动态删除会使其周围元素的指针改变，会发生内存泄漏、指针悬挂等现象，所以果断要用erase的范围删除操作[low,up)。
没啥说的，复杂度均摊下来很小，因为不会重复统计，所以顶多是NlogN的复杂度，再加上离散化的复杂度，整体NlogN。

老话，STL能做，为啥要手写？出题卡STL的就是sb，不解释；至于什么叫卡STL，各位大牛都懂得。
今天弱爆了，就这样吧。
附代码：

#include <iostream>
#include <cstdio>
#include <set>
#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 100005
struct point
{
    int x,y;
    point(){}
    point(int a,int b):x(a),y(b){}
}p[maxn];
int x[maxn],y[maxn];
int n,m;
vector <int> X[maxn],Y[maxn];
map <int,int> MX,MY;
vector <int> ::iterator xlow,xup,ylow,yup,idx,idy;
int main()
{
    while(scanf("%d %d",&n,&m) == 2 && (n || m))
    {
        MX.clear();
        MY.clear();
        for(int i = 1;i <= n;i++)
        {
            if(!X[i].empty())
                X[i].clear();
            if(!Y[i].empty())
                Y[i].clear();
        }
        for(int i = 0;i < n;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            p[i] = point(a,b);
            x[i] = a;
            y[i] = b;
        }
        sort(x,x + n);
        sort(y,y + n);
        int cntx = 1,cnty = 1;
        for(int i = 0;i < n;i++)
        {
            if(MX[x[i]] == 0)
                MX[x[i]] = cntx++;
            if(MY[y[i]] == 0)
                MY[y[i]] = cnty++;
        }
        for(int i = 0;i < n;i++)
        {
            p[i].x = MX[p[i].x];
            p[i].y = MY[p[i].y];
            idx = lower_bound(X[p[i].x].begin(),X[p[i].x].end(),p[i].y);
            X[p[i].x].insert(idx,p[i].y);
            idy = lower_bound(Y[p[i].y].begin(),Y[p[i].y].end(),p[i].x);
            Y[p[i].y].insert(idy,p[i].x);
        }
        for(int i = 0;i < m;i++)
        {
            int mod,d;
            scanf("%d %d",&mod,&d);
            if(mod == 0)
            {
                d = MX[d];
                printf("%d\n",X[d].size());
                if(X[d].empty())
                    continue;
                for(idx = X[d].begin();idx != X[d].end();idx++)
                {
                    int p = *idx;
                    ylow = lower_bound(Y[p].begin(),Y[p].end(),d);
                    yup = upper_bound(Y[p].begin(),Y[p].end(),d);
                    Y[p].erase(ylow,yup);
                }
                X[d].clear();
            }
            else
            {
                d = MY[d];
                printf("%d\n",Y[d].size());
                if(Y[d].empty())
                    continue;
                for(idy = Y[d].begin();idy != Y[d].end();idy++)
                {
                    int p = *idy;
                    xlow = lower_bound(X[p].begin(),X[p].end(),d);
                    xup = upper_bound(X[p].begin(),X[p].end(),d);
                    X[p].erase(xlow,xup);
                }
                Y[d].clear();
            }
        }
        puts("");
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-10 19:10 发表评论

HDU 3212 Card Collection【两个虚拟根或者一个】 && HDU 2121 Ice_cream’s world II 【不定根的最小树形图】

BUPT-[aswmtjdsj] @ Penalty — Mon, 05 Sep 2011 05:51:00 GMT

摘要: 3212地上有一堆卡片。捡起来需要时间，必须一张一张捡起。根据给定关系，如果有特定卡片b，捡起卡片a的时间会加快。手里已有“THE_WINDY"卡。连虚根1到所有卡片（除上述），权值为捡起该卡片的原本时间，其他边根据给定关系连接。再连虚根2到虚根1和”THE_WINDY"，边权为已知总权和+1。做最小树形图，将得到的答案减小到sum+1以下（去掉多余的边，至多两条）。ps当... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-09-05 13:51 发表评论

HDU 4009 Transfer water 【最小树形图】

BUPT-[aswmtjdsj] @ Penalty — Sun, 04 Sep 2011 04:39:00 GMT

模板题，不解释。
详细介绍请见百度百科http://baike.baidu.com/view/5944982.htm或者1963年的刘朱算法论文（谁有啊？求个链接）。
复杂度O(V*E)。模板详见胡浩NotOnlySuccess大牛的blog（http://www.notonlysuccess.com/?p=315）。

本题添加一个树根，连到所有点，边权为每点的打井费用，其他套模板。
附代码，顺便感谢hh大牛和戴牛！！！

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 1005
#define type int
const int inf = ~0u >> 1;
struct node
{
    int u,v;
    type cost;
    node(){}
    node(int _u,int _v,type _c):u(_u),v(_v),cost(_c){}
}e[maxn * maxn];
int pre[maxn],id[maxn],vis[maxn];
type in[maxn];
type dirmst(int root,int nv,int ne)
{
    type ret = 0;
    while(1)
    {
        //find the smallest in-arc
        fill(in,in + nv,inf);
        for(int i = 0;i < ne;i++)
        {
            int u = e[i].u;
            int v = e[i].v;
            if(e[i].cost < in[v] && u != v)
            {
                pre[v] = u;
                in[v] = e[i].cost;
            }
        }
        for(int i = 0;i < nv;i++)
        {
            if(i == root)
                continue;
            if(in[i] == inf)
                return -1;//there are some nodes other than root with no in-arc connected to it
        }
        //find the dir circle
        int cntnode = 0;
        fill(id,id + nv,-1);
        fill(vis,vis + nv,-1);
        in[root] = 0;
        for(int i = 0;i < nv;i++)
        {
            ret += in[i];
            int v = i;
            while(vis[v] != i && id[v] == -1 && v != root)
            {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && id[v] == -1)
            {
                for(int u = pre[v]; u != v;u = pre[u])
                    id[u] = cntnode;
                id[v] = cntnode++;
            }
        }
        if(cntnode == 0)
            break;//no circle
        for(int i = 0;i < nv;i++)
            if(id[i] == -1)
                id[i] = cntnode++;
        //compress the nodes
        for(int i = 0;i < ne;i++)
        {
            int v = e[i].v;
            e[i].u = id[e[i].u];
            e[i].v = id[e[i].v];
            if(e[i].u != e[i].v)
                e[i].cost -= in[v];
        }
        nv = cntnode;
        root = id[root];
    }
    return ret;
}
int n,tot,X,Y,Z;
int ab(int x)
{
    return x >= 0?x:-x;
}
struct point
{
    int x,y,z;
    point(){}
    point(int a,int b,int c):x(a),y(b),z(c){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y,z - p.z);
    }
    int dis()
    {
        return ab(x) + ab(y) + ab(z);
    }
}p[maxn];
int main()
{
    while(scanf("%d %d %d %d",&n,&X,&Y,&Z) == 4 && (n || X || Y || Z))
    {
        tot = 0;
        for(int i = 1;i <= n;i++)
        {
            int a,b,c;
            scanf("%d %d %d",&a,&b,&c);
            p[i] = point(a,b,c);
            e[tot++] = node(0,i,ab(p[i].z) * X);
        }
        for(int i = 1;i <= n;i++)
        {
            int opt;
            scanf("%d",&opt);
            for(int j = 0;j < opt;j++)
            {
                int a;
                scanf("%d",&a);
                if(a == i)
                    continue;
                int temp = Y * (p[i] - p[a]).dis();
                if(p[i].z < p[a].z)
                    temp += Z;
                e[tot++] = node(i,a,temp);
            }
        }
        int ans = dirmst(0,n + 1,tot);
        if(ans == -1)
            puts("poor XiaoA");
        else
            printf("%d\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-04 12:39 发表评论

HDU 4007 Dave 【双扫描线暴力】

BUPT-[aswmtjdsj] @ Penalty — Sun, 04 Sep 2011 04:04:00 GMT

比赛的时候用线段树做这题要么是不嫌麻烦就是贴标程了。。。那么水的题，1000的数据范围，果断N^2暴力啊。。
场上的时候claire大神瞬间1A，太犀利了。
维护四根双维度扫描线。
把读入的点copy一遍，一组x排序，一组y排序，用于两种扫描线的统计。
两根水平的，一左一右，保证距离不大于R；两根竖直的，用于统计，保证距离不大于R，且对于线框内的每个点判断是否在水平两根线的范围内，如果是则计数器加1，且当下扫描线上移时，如果是已经统计过的点则计数器减1。整体的思想类似队列。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 1005
struct point
{
    int x,y;
    point(){}
    point(int a,int b):x(a),y(b){}
}ver[maxn],par[maxn];
bool cmpx(point a,point b)
{
    return a.x < b.x;
}
bool cmpy(point a,point b)
{
    return a.y < b.y;
}
int n,R;
int main()
{
    while(scanf("%d %d",&n,&R) == 2)
    {
        for(int i = 0;i < n;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            ver[i] = point(a,b);
            par[i] = point(a,b);
        }
        sort(ver,ver + n,cmpy);
        sort(par,par + n,cmpx);
        int posl,posr,posu,posd;
        int l = 0,r = 0,u = 0,d = 0;
        int ans = 0;
        for(l = 0;l < n;l++)
        {
            posl = par[l].x;
            while(par[r].x - posl <= R && r < n)
                r++;
            posr = par[r - 1].x;
            u = 0;
            int temp = 0;
            for(d = 0;d < n;d++)
            {
                posd = ver[d].y;
                if(d != 0 && ver[d - 1].x <= posr && ver[d - 1].x >= posl)
                    temp--;
                for(;u < n;u++)
                {
                    if(ver[u].y - posd > R)
                        break;
                    if(ver[u].x >= posl && ver[u].x <= posr)
                        temp++;
                }
                ans = max(ans,temp);
                if(u == n - 1)
                    break;
            }
        }
        printf("%d\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-04 12:04 发表评论

HDU 4006 The kth great number 【STL 使用练习】

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

今天的题都是队友出的，我就出了这道水题～

贴个短代码STL。。。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
int main()
{
    int n,k;
    while(scanf("%d %d",&n,&k) == 2)
    {
        priority_queue<int,vector<int>,greater<int> > Q;
        for(int i = 1;i <= n;i++)
        {
            char opt;
            scanf(" %c",&opt);
            if(opt == 'I')
            {
                int a;
                scanf("%d",&a);
                Q.push(a);
                if(Q.size() > k)
                    Q.pop();
            }
            else
                printf("%d\n",Q.top());
        }
    }
}

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

HDU 3986 & HDU 3987 & HDU 3991 【多校第十五场WHU 三道模板题】

BUPT-[aswmtjdsj] @ Penalty — Tue, 30 Aug 2011 13:36:00 GMT

这三题是这场比赛的3道模板题。
1005 即 3986 题，枚举+最短路。
首先求一遍spfa，令ans=dis[n]，并记录最短路径树，延终点到起点枚举（根据pre数组，记点，和mark数组，记邻接表边的编号），每次拆一条边，再做一遍spfa，如果断路则直接输出-1，否则比对当前值与ans的大小。
复杂度上界是O(M * M * C)，C是一个大常数，这是一个俨然达不到的上界。首先最短路径上的边数虽然最坏情况下正比于M，但是这样的话随便拆一条边都应该break，而对于一般情况最短路径上面的边数又是应该远小于M的，所以第一个M，即枚举最短路上的边数，真实的复杂度应该是n。况且，既然题目的数据是随机给出的，最短路上的边数可能是一个很小的数字，因而最终的复杂度可以理解为O(M * K)，K也是一个常数。
表示此题就是不敢写，敢写真是各种水过。
1006 即 3987 题，最小割边数最小。
最大流等于最小割，显然。而想让最小割中的边数最小，即，一个比较简单的想法就是，一条增广路上面只要割一条边就好。
我的做法，按原图建好网络流图之后（无向边什么的怎么处理都是常识哈），对于每条边乘以一个大数（大于总边数）再加1，然后流之，最后maxflow % 大数即为最小割最少边数的边。
证明，假设第i条增广路的原始流量为xi，那么现在的流量是A*xi+1，A为大数；最后的maxflow，原图为sigma(xi),新图为A*sigma(xi)+B，那么这里的B其实就是增广路条数。输出B即可。所以要把A设置的大一点，以防被B超越。
解题报告的做法是，原图流完最大流后，建新图，把原图的最小割集中的边添到新图中去，容量为1，再流一遍最大流，即为答案。这两种做法本质相同。

1010 即 3991题，最小路径覆盖。
如果做过poj2060题，会发现这两题一模一样。floyd预处理地图，然后把Q个要求拆点，满足约束的点连有向边，做匈牙利，输出Q-ans-1即可。（邻接矩阵的hungary貌似超时？需要邻接表或者hopcroft？）

代码就不贴了。都是模板题，网上都能搜到代码。
模板题神马的，用来增长自信是吗？一如戴牛所说。

BUPT-[aswmtjdsj] @ Penalty 2011-08-30 21:36 发表评论

HDU 3972 1M Possible 【乱搞】

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

http://acm.hdu.edu.cn/showproblem.php?pid=3972
这种题算是脑筋急转弯题吧- -，一切都是珂神的大脑- -

先说一道这类型题目的入门题。
给你3n+1个数，让你找出多出来的那个数（其他是n个等价三元组）。
鉴于三元组的“三”和卡内存什么的。。。所以按二进制位搞之吧。。
把读入的数字按二进制展开，存到一个[32]的数组里面，如果某位为1则对应元素++。
然后把这个数组中的每个元素的值都模3。把这个数组的元素按二进制数还原回一个整数，还原的时候某元素非0则对应为1。
这个数就是所求。

再看这题，是多出来两个数，那么按照上面的方法做，把最后一步改一下，还原二进制数的时候就按照对应元素来还原（而非1/0），那么还原来的数字是什么呢？
假设最后剩下的数字是a和b，那么还原回来的数字就是X=a+b。因为加法的本质就是按位加。
那只有“和”是求不出来解的啊少年。
于是珂神想出了一种方法，就是再次记录这些数字，但通过不同的形式，让其表现的不同，从而建立一个二元关系方程组来求解。
把读入的每个数都平方，再按照上面的方法统计在一个[64]的数组里面（因为会long long）。
最后还原回来的数字就是Y=a^2+b^2。
然后联立解方程即可。
恶心的地方在于因为出现的最大数字为2^31-1，所以中间处理精度和算数上溢的时候要无比小心。
因为中间出现了a+b，所以还原的数字要用unsigned int存。
因为中间出现了a^2+b^2而且解方程的时候中间值有它的2倍，所以还原的数字要用unsigned long long 存。
然后另一个问题就是位移操作的操作数要注意，结果为long long或者为unsigned long long的位移，左操作数要为对应类型，即1ll或者1llu。
解方程的时候亏着没被精度卡掉，太感动了。
注意输出顺序和delta=0的时候。
附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
int small[65],big[65];
typedef unsigned long long ull;
const ull whatfuck = 1;
void gao()
{
    int n;
    scanf("%d",&n);
    memset(small,0,sizeof(small));
    memset(big,0,sizeof(big));
    for(int i = 0;i < n;i++)
    {
        int opt;
        ull num;
        scanf("%d",&opt);
        num = (ull)opt * (ull)opt;
        for(int j = 0;j < 31;j++)
        {
            small[j] += ((opt >> j) & whatfuck);
            small[j] %= 3;
        }
        for(int j = 0;j < 63;j++)
        {
            big[j] += ((num >> j) & whatfuck);
            big[j] %= 3;
        }
    }
    ull SMALL = 0;
    ull BIG = 0;
    for(int i = 0;i < 31;i++)
        if(small[i])
            SMALL += (ull)small[i] * (whatfuck << i);
    for(int i = 0;i < 63;i++)
        if(big[i])
            BIG += (ull)big[i] * (whatfuck << i);
    double det = 2 * BIG - SMALL * SMALL;
    int fuck1,fuck2;
    double x1 = 0.5 * (SMALL + sqrt(det)),x2 = 0.5 * (SMALL - sqrt(det));
    fuck1 = min(x1,x2),fuck2 = max(x1,x2);
    printf("%d %d\n",fuck1,fuck2);
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)
        gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-25 19:47 发表评论

HDU 3961 Crisis【恶心的几何模拟】

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

摘要: 链接：http://acm.hdu.edu.cn/showproblem.php?pid=3961这题竟然有队伍场上过掉了。。大神们的脑子得有多清楚。。。我这题是做了一天才理清思路，过了样例。。这题的样例就已然强的一B了。。题目大意即做法，题意很裸，直接把做法说出来了，所以就是模拟题咯。先给你一个圆和圆外一点，然后给你一个多边形（不一定凸凹），将多边形绕圆心公转，同时自转，给你转动周期和时间。让你... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-08-24 21:26 发表评论

HDU 3955 March【读题困难的BFS/PFS】

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

摘要: 链接：http://acm.hdu.edu.cn/showproblem.php?pid=3955这题的《Civilization》背景导致不少没玩过这款经典游戏的acmer悲剧了。这。。。表示还好没被读题坑了。。。不过敲着敲着就发现一处关键点没处理的时候感觉实在是太蛋疼了。。。果然这种比较恶心的题，要先设计好状态再开搞才是正确策略。100*100的有限制地图，给一个起点，给一个终点，给一个行动值... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-08-18 19:46 发表评论

HDU 3931 Cross the Fire ［陈题，无向图最小权点割］

BUPT-[aswmtjdsj] @ Penalty — Fri, 12 Aug 2011 16:57:00 GMT

Cross the Fire

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 146 Accepted Submission(s): 64

Problem Description

Our hero is planned to cross an important street, the other side of the street is the headquarters of the enemy. The whole street is a rectangle with length L and width W. Because the streets are sealed of the building block on both up and down side, we assumed people can only walk down on the street but not get out the up and down board.
In order to prevent our hero, the evil enemy layout N mines in the street. Due to internal staff informed in advance, the hero has known the distribution of all mines, and their explosion radius and explosion power. The mine enemy used is an amazing sense-mine, as long as the person come into its sensing radius, it will explode, due to unknown reasons, the explosion radius of each mine is same to its sensing radius. Heroes have a certain strength value at first, but once he touching a mine, he will lose some strength value same to the explosion power of this mine. Once the hero's strength value is not greater than zero, he will die.
Now hero want you to help him calculate whether there is a path so that he can live to reach the enemy headquarters. If he can live to cross the street, he wants to know the maximum remaining strength value after crossing the street. We assume the hero's path trajectory is arbitrary.

Input

The input consists of several test cases.
The first line contains four integers L, W, N and P– the length and the width of the street, the number of mines, and the initial strength value of hero, respectively(1 ≤ L ≤ 10000 ,1 ≤ W ≤ 10000, 1 ≤ N ≤ 250, 1 ≤ P ≤ 1000000). Each of the following N lines contains four integers Xi, Yi, Ri and Pi – the coordinates, the sensing radius(explosion radius) and the explosion power of i-th mine in the street (0 ≤ Xi ≤ L, 0 ≤ Yi ≤ W, 1 ≤ Ri ≤ 100, 1 ≤ Pi ≤ 10000). The coordinates and radius are given in meters, relative to the street: the southwestern corner of the street has coordinates (0, 0), and the northeastern corner of the street has coordinates (L, W).
Note that crossing the street may start at coordinate (0, ys ) for any 0 ≤ ys ≤ W and end at coordinate (L, ye ) for any 0 ≤ ye ≤ W . Neither ys nor ye need to be integer.

Output

For each input cases, if our hero cannot live to cross the street, please output “Our hero has been killed”; otherwise output the maximum remaining strength value after crossing the street.

Sample Input

130 340 5 2
10 50 100 1
130 130 100 1
70 170 100 1
0 180 100 1
60 260 100 1

Sample Output

Source

2011 Multi-University Training Contest 10 - Host by HRBEU

先自我吐槽：
一开始贪心建图来着。wa了。后来被肖神举出了反例。然后联想到了poj3281。果断最小割点权图必然要拆点的，而非一般建图或者贪心建图。因为错误建图会导致某点点权被重复使用，所以错误性显然。
给一组贪心建图反例，肖神给的。YM
s-1(10),s-2(10),1-3(5),2-3(5),3-4(5),3-5(5),4-t(10),5-t(10)
本组样例中3点的点权就被重复使用了，流出了错误割10，实际上应为5。
正确建图：
s-1(inf),s-2(inf),1-1'(10),2-2'(10),1-3(inf),2-3(inf),3-3'(5),3-4(inf),3-5(inf),4-4'(10),5-5'(10),4-t(inf),5-t(inf).

本题捉法：
YY半天圆交和路径规划，发现都不会写，于是场上悲剧了。赛后被人提醒最小割，果断有想法。唉，场上多yy才是王道。
建图：
本题中的炸弹如果想对“主角”造成困扰，至少要出现上连上边界，下连下边界，中间封住才可以。于是易得把边界做源汇，各圆做中继点的想法。
~~一开始的想法是边容量以两圆中较小的伤害值为准。~~
后来发现这种建图错误显然。
经各种神的提携之后，意识到无向图点权割果断要拆点转化为边割才可解，于是就有了如下建图：
每圆拆点，入点->出点，容量为点权。相交的圆以及和源汇相交的圆之间连边，容量正无穷。圆间无向，源汇和圆间无向。注意连边方式为出点->入点，分清出入点p,p'。
跑个最大流。这都是后话了。
弱爆了，要善于yy，多想想建图方式啊！！！

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
#define maxn 505
#define maxm 260000
const int inf = ~0u >> 1;
struct circus
{
    int x,y,r,p;
    circus(){}
    circus(int a,int b,int c,int d):x(a),y(b),r(c),p(d){}
}cir[maxn];
struct edge
{
    int p,next,val;
    edge(){}
    edge(int a,int b,int c):p(a),next(b),val(c){}
}e[maxm];
int l,w,p,n,N,tot,flow[maxn],pre[maxn],v[maxn],arc[maxn],path[maxn],cnt[maxn],d[maxn];
void init()
{
    n = 2*N + 1;
    tot = 0;
    memset(v,-1,sizeof(v));
    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);
    v[p] = tot++;
    e[tot] = edge(p,v[q],0);
    v[q] = tot++;
}
int mflow()
{
    int s = 0,t = n;
    int sum,now,k,loc,i,least;
    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 && least > d[e[k].p])
                {
                    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 main()
{
    while(scanf("%d %d %d %d",&l,&w,&N,&p) == 4)
    {
        init();
        for(int i = 1;i <= N;i++)
        {
            int a,b,c,d;
            scanf("%d %d %d %d",&a,&b,&c,&d);
            cir[i] = circus(a,b,c,d);
        }
        for(int i = 1;i <= N;i++)
        {
            add(i,i + N,cir[i].p);
            if(cir[i].y <= cir[i].r)
                add(0,i,inf);
            if(w - cir[i].y <= cir[i].r)
                add(i+N,n,inf);
        }
        for(int i = 1;i <= N;i++)
            for(int j = i + 1;j <= N;j++)
            {
                if((cir[i].x - cir[j].x) * (cir[i].x - cir[j].x) + (cir[i].y - cir[j].y) * (cir[i].y - cir[j].y) <= (cir[i].r + cir[j].r) * (cir[i].r + cir[j].r))
                {
                    add(i+N,j,inf);
                    add(j+N,i,inf);
                }
            }
        int ans = mflow();
        if(p > ans)
            printf("%d\n",p - ans);
        else
            puts("Our hero has been killed");
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-13 00:57 发表评论

HDU 3927 Math Geek 【这你妹的乱搞】

BUPT-[aswmtjdsj] @ Penalty — Tue, 09 Aug 2011 10:26:00 GMT

链接：http://acm.hdu.edu.cn/showproblem.php?pid=3927

真不想多说。。随便搞。。。
用
1 2 3 16
4 5 6 15
7 8 9 14
10 11 12 13 的方法构造出来。
然后随便（或者说随机）调整一下。。然后就过了。。。
只能说明幻方的解集很小，反幻方的解集太大了吧。。随便就能够造出来。。。n=3记得特判就好。

代码：

#include <iostream>

#include <cstdio>
using namespace std;
#define maxn 205
int mat[maxn][maxn];
void gao()
{
    int n;
    scanf("%d",&n);
    if(n == 3)
    {
        mat[1][1] = 7;
        mat[1][2] = 5;
        mat[1][3] = 2;
        mat[2][1] = 1;
        mat[2][2] = 4;
        mat[2][3] = 8;
        mat[3][1] = 3;
        mat[3][2] = 6;
        mat[3][3] = 9;
    }
    else
    {
        int cnt = 1;
        for(int i = 1;i <= n - 1;i++)
            for(int j = 1;j <= n - 1;j++)
                mat[i][j] = cnt++;
        for(int j = 1;j <= n;j++)
            mat[n][j] = cnt++;
        for(int i = n - 1;i >= 1;i--)
            mat[i][n] = cnt++;
        for(int i = 1;i <= n/2;i++)
            swap(mat[i][n],mat[n][n-i+1]);
    }
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
            printf("%d%c",mat[i][j],(j==n)?'\n':' ');
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 1;i <= t;i++)
    {
        printf("Case #%d:\n",i);
        gao();
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-09 18:26 发表评论

HDU 3912 Turn Right 【水题模拟搜索】

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

Turn Right

Time Limit: 6000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 414 Accepted Submission(s): 159

Problem Description

This summer, ELT and his classmates went to Beijing for a training of coding. ELT have never been to Beijing before, so at the weekend, he together with some friends went to the National Museum, it's free for students!

  The National Museum consists of many parts. One part of it is an exhibition of Ancient China From Xia Dynasty to Qing Dynasty, it needs a big room to show all the things. What's more, there exist many walls to hang pictures. The boundary of this room is walls except the entrance and exit.

  With walls, an entrance and an exit, this room can be regarded as a maze. To make it simple, this room is a R*C grid, wall is constructed at some edges of grid. The entrance is always at the first row, and the exit is always at the last row, just like the picture below.

ELT can't remember his direction in maze, but he is a clever boy. He knew an algorithm called "Always Turn Right", it's procedure is as follows: at any grid of this room, if we can turn right(no wall at right side), then we must turn right; if we can't turn right but can go straight forward, then we must go forward; if we can't go forward but can turn left, then we must turn left; if we can't even turn left, we just turn backward. In the picture above, if we use this algorithm, we'll visit these grids in order: Entrance --> (0, 1) --> (0, 0) --> (0, 1) --> (0, 2) --> (1, 2) --> (1, 1) --> (1, 0) --> (2, 0) --> (1, 0) --> (1, 1) --> (2, 1) --> (2, 2) --> Exit. Very easy, doesn't it?

  ELT uses "Always Turn Right" algorithm to visit this room from entrance to exit, and then from exit to entrance. He wants to know whether he walked all grids in the room. Now ELT is dizzy because the maze is too big, can you help him?

Input

First line is an integer T, means T test cases. In each test case, the first line has four numbers: R, C, Ent_Column, Exit_Column. Ent_Column is the column number of entrance; Exit_Column is the column number of exit.
Then following 2*R-1 lines, 2*i line have C-1 numbers, the j-th number shows whether there is a wall between grid(i, j) and grid(i, j+1), 2*i+1 line have C numbers, the j-th number shows whether there is a wall between grid(i, j) and grid(i+1, j). Number 1 represents a wall, 0 represents no wall.
We guarantee that there exists a path from entrance to exit.
2 <= R, C <= 500
0 <= Ent_Column, Exit_Column < C

Output

If ELT can walk all grids in the room, print one line "YES", otherwise, print one line "NO".

Sample Input

Sample Output

YES

Source

2011 Multi-University Training Contest 8 - Host by HUST

表示做这种非递归非“传统”迭代的搜索总会脑抽。。。总是不自觉的想回溯或者什么的blabla。。
just按照题目给出的顺序模拟就好，简化写法就写个状态转移，三维标记状态、三维标记障碍即可。
读入建图比较坑爹，不过还是那句话，完全按照“题目所述”，就很easy。
迭代搜索那块就是写的清楚明白就绝不坑爹。

虽然有更好的做法，但是这复杂度，俨然不会超，就这样吧。何况那做法也没有啥本质上的优化。
ps，这题类似poj3083.。。
代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#define maxn 505
bool vis[maxn][maxn][5],map[maxn][maxn][5];
int dx[] = {0,1,0,-1};
int dy[] = {1,0,-1,0};
int rot[] = {1,0,3,2};
int r,c,st,en;
bool check(int x,int y,int dir,bool a)
{
    return ((x >= 1 && x <= r) && (y >= 1 && y <= c) && !vis[x][y][dir]) || (x == r + 1 && y == en && a == 0) || (x == 0 && y == st && a == 1);
}
void gao()
{
    scanf("%d %d %d %d",&r,&c,&st,&en);
    st++;
    en++;
    memset(map,0,sizeof(map));
    for(int i = 0;i < 2 * r - 1;i++)
    {
        if(i % 2 == 0)
        {
            for(int j = 1;j <= c - 1;j++)
            {
                int a;
                scanf("%d",&a);
                map[i/2+1][j][0] = map[i/2+1][j+1][2] = a;
            }
        }
        else
        {
            for(int j = 1;j <= c;j++)
            {
                int a;
                scanf("%d",&a);
                map[(i+1)/2][j][1] = map[(i+1)/2+1][j][3]= a;
            }
        }
    }
    memset(vis,0,sizeof(vis));
    int x,y,d,tx,ty,td;
    x = 1;
    y = st;
    d = 1;
    bool md = 0;
    while(1)
    {
        if(x == r + 1 && y == en)
        {
            x = r;
            y = en;
            d = 3;
            md = 1;
            continue;
        }
        vis[x][y][d] = true;
        bool flag = false;
        for(int i = 0;i < 4;i++)
        {
            td = (d + rot[i])%4;
            tx = x + dx[td];
            ty = y + dy[td];
            if(!map[x][y][td] && check(tx,ty,td,md))
            {
                x = tx;
                y = ty;
                d = td;
                flag = true;
                break;
            }
        }
        if(!flag)
            break;
    }
    bool flag = true;
    for(int i = 1;i <= r;i++)
    {
        for(int j = 1;j <= c;j++)
        {
            bool mark = false;
            for(int k = 0;k < 4;k++)
                if(vis[i][j][k])
                {
                    mark = true;
                    break;
                }
            if(!mark)
            {
                flag = false;
                break;
            }
        }
        if(!flag)
            break;
    }
    puts((flag)?"YES":"NO");
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-05 21:51 发表评论

HDU 3917 Road constructions【最大权闭合子图脑抽的建图】

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

Road constructions

Time Limit: 6000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 149 Accepted Submission(s): 46

Problem Description

N cities are required to connect with each other by a new transportation system. After several rounds of bidding, we have selected M constructions companies and
decided which section is assigned to which company, the associated cost and the direction of each road.

Due to the insufficiency of national fiscal revenue and special taxation system （the tax paid by each company pays is a fixed amount and tax payment occurs at the
beginning of the construction of the project） The government wishes to complete the project in several years and collects as much tax as possible to support the public
expense

For the restrictions of construction and engineering techniques, if a company is required to start the construction, then itself and its associated companies have to
complete all the tasks they commit (if company A constructs a road
from city 1 to city 2, company B constructs a road from city 2 to city 3, company C constructs a road from city 1 to city 3, we call
companies A and B are associated and other company pairs have no such relationship, pay attention, in this example and a are not associated, in other words,’
associated' is a directed relationship).
Now the question is what the maximum income the government can obtain in the first year is？

Input

There are multiple cases (no more than 50).
  Each test case starts with a line, which contains 2 positive integers, n and m (1<=n<=1000, 1<=m<=5000).
  The next line contains m integer which means the tax of each company.
  The Third line has an integer k (1<=k<=3000)which indicates the number of the roads.
  Then k lines fellow, each contains 4 integers, the start of the roads, the end of the road, the company is responsible for this road and the cost of the road.
  The end of the input with two zero

Output

For each test case output the maximum income in a separate line, and if you can not get any income, please output 0.

Sample Input

Sample Output

440 
470 
0

Hint
for second test case, if you choose company 2 responsible ways, then you must choose the path of responsible company 1, but if you choose company 1, then you do not have to choose company 2.

Source

2011 Multi-University Training Contest 8 - Host by HUST

关于最大权闭合子图的最大流解法证明请参见胡伯涛Amber的集训队论文或者Ahuja的网络流算法书。还有NOI2006的最大获利。
这题建图就是，源点连每个公司，容量为收益（税收），汇点连每个公司，容量为总费用（每个公司所commit的），存在关系的公司之间连边，容量正无穷。
最后答案即为收益总和-最大流。
注意点：
1.我之前写最大获利的时候是建了4层的一个图，源-->收益点-->花费点-->汇。是因为每个收益点依赖的花费点有重叠的情况，重叠的不能重复算，所以必须靠流来自主选择；而本题只需3层即可，源-->收益点-->汇，因为每个收益点所必需的花费已然确定，直接把花费连到汇即可。
2.本题能用的到的点就3000个（k <= 3000）。。。我了个去。
3.建立公司之间的依赖关系太蛋疼了，为了这个重写了这代码三遍。第一次DFS，有标记会导致建立不全，无标记就是N!会TLE；第二次按城市点枚举建图，莫名其妙写错了，不知道错哪儿了；第三次按边枚举终于过了，期间还因为边开小了RE了一次，不过这道题的边数还真挺不好算的。。
总结：网络流永远是建图恶心，见过的模型越多越好。（最大权闭合子图-->点之间的依赖关系，有收益有花费）
代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 5005
#define maxm 100000
#define maxtn 1005
#define maxk 3005
struct edge
{
    int p,next,val,anti;
    edge(){}
    edge(int _p,int _n,int _v):p(_p),next(_n),val(_v){}
    edge(int _p,int _n,int _v,int _a):p(_p),next(_n),val(_v),anti(_a){}
}v[maxn],e[maxm],arc[maxn],temp[maxtn],ed[maxk];
int path[maxn],flow[maxn],pre[maxn],cnt[maxn],d[maxn];
int tot,n,tn,tm,tk,sum;
int value[maxn],cost[maxn];
const int inf = ~0u >> 1;
void init()
{
    tot = 0;
    sum = 0;
    n = tm + 1;
    for(int i = 1;i <= tn;i++)temp[i].next = -1;
    for(int i = 0;i <= n;i++)v[i].next = -1;
    memset(d,0,sizeof(d));
    memset(cnt,0,sizeof(cnt));
    memset(value,0,sizeof(value));
    memset(cost,0,sizeof(cost));
    cnt[0] = n + 1;
}
void add(int p,int q,int 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++;
}
void daa(int p,int q,int val,int id)
{
    ed[id] = edge(q,0,val);
    e[tot] = edge(q,temp[p].next,val);
    temp[p].next = tot++;
}
int mflow()
{
    int s = 0,t = n;
    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[s] < n + 1;)
    {
        flow[i] = now;
        for(flag = false,k = arc[i].next;~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].next = k;
                i = e[k].p;
                if(i == t)
                {
                    for(total += 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].next;~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].next = loc;
            d[i] = least + 1;
            cnt[d[i]]++;
            if(i != s)
            {
                i = pre[i];
                now = flow[i];
            }
        }
    }
    return total;
}
int main()
{
    while(scanf("%d %d",&tn,&tm) == 2 && (tn || tm))
    {
        init();
        for(int i = 1;i <= tm;i++)
        {
            scanf("%d",&value[i]);
            sum += value[i];
        }
        scanf("%d",&tk);
        for(int i = 0;i < tk;i++)
        {
            int a,b,c,d;
            scanf("%d %d %d %d",&a,&b,&c,&d);
            cost[c] += d;
            daa(a,b,c,i);
        }
        for(int i = 0;i < tk;i++)
        {
            int p = ed[i].p,a = ed[i].val;
            for(int k = temp[p].next;~k;k = e[k].next)
            {
                int b = e[k].val;
                if(a != b)
                    add(a,b,inf);
            }
        }
        for(int i = 1;i <= tm;i++)
        {
            add(0,i,value[i]);
            add(i,n,cost[i]);
        }
        int ans = mflow();
        printf("%d\n",sum - ans);
    }
}

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

HDU 3883 CS and Sugar ［DP 以序消除后效性树状数组快速统计］

BUPT-[aswmtjdsj] @ Penalty — Sun, 31 Jul 2011 04:14:00 GMT

CS and Sugar

Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65768/32768 K (Java/Others)
Total Submission(s): 190 Accepted Submission(s): 89

Problem Description

CS and Sugar find a new continent at the same time. Rare plants are all over this miraculous land, so they decided to take them home and sell it. But obviously, not all plants can be sold at a good price. Some plants are just usual weed. After some time of observation, they became self-taught botanists. CS and Sugar divided a rectangle area into n*m grids, and marked them with different values (maybe negative). They dig in turns to be fare, when all the plants in a grid are taken by the last person, and next person start to move on. The next person always chooses the one of the grids which are above and left to the last person, including the straight above or straight left. And even that, CS and Sugar still tried to compete with each other, and they always choose the available part with higher absolute value than last one no matter positive or negative. The first person can choose any grid to begin. Until someone is not able to make any move, they left. They are now debating who should dig first because they have already calculated how many advantages the first person can get.

Input

Multiple test cases (no more than 100), for each case:
The first line contains two integers n and m (0Following n lines, each line contains m integers whose absolute value is no more than 100, representing the value in each part.

Output

For each case, output one integer, representing the maximum advantage the first person can get in total value.

Sample Input

1 5
-5 -4 -3 -2 -1
2 2
-7 -6
-6 5
3 2
-6 -5
-4  -4
2  4

Sample Output

1
4
3

Author

zyue1105

Source

2011 Multi-University Training Contest 5 - Host by BNU

链接：http://acm.hdu.edu.cn/showproblem.php?pid=3883
题意：两个那啥挖矿，轮流的。第一铲子落点任意自选。每一铲子的落点都要在上一铲子的“非严格”左上区间内，且格中value的绝对值要大于上一选格中value的绝对值。
两人都最优策略求自己最后总值最大。问最后的两人差值为多少。
解：
感谢ykprocess大神场上ac这题，赛后还给本菜讲题。YMYMYM！

乍一看像博弈。也差不多确实是，不过在两人均最优策略的情况下，这题转化为一个DP了。
从末态向初态推，消后效性；每一步都选择上一步（其实是后一步）最大的那个dp值，减掉它，就是当前状态的最优解。
状态转移就是dp[x][y] = (max(1..x,1..y)dp[i][j] == -inf)?map[x][y]:map[x][y] - max;

本题的两个特点，将读入的点全部排序，按照abs(val)降序>x降序>y降序排列。第一序保证了无后效性的关键，即先更新掉绝对值大的点，每次更新的时候就不用去判断当前点与查询出来的点绝对值大小关系了。后两个序其实没必要，只是保证了绝对值相同的点同时更新而已：这样就可以使得xy坐标大的点先更新，从而不会让绝对值相同的点互相更新，这样会导致错误的结果。感谢james0zan大神给本菜讲解了这个序的关键作用。YMYMYMYM！

由于这题矩阵是100*100的。。所以如果每步naive的查询最大值，会让复杂度退化到O(100*4)的复杂度。所以果断上数据结构－－树状数组。二维树状数组使得查询最大值的复杂度降为(logn)^2。。所以该题的总复杂度为O(NM*log(N*M) + NM*log(N*M))=O(N^2*log^2(N))的。
二维树状数组查询最大值是第一次写，中间遇到不少困难。说几个要点：lowbit啥用不解释，更新结点最大值的时候是从小往大更新，因为当前结点会被x + lowbit(x) (<=n)的这些点们所管辖(if val > treearray[x][y] then update)。。而查询的时候则是从大往小查询，因为x - lowbit(x)管辖这些子矩阵中的最大值。

另外因为是二维的。。所以千万不要这么写：

for(;x > 0; x -= lowbit(x))
for(;y > 0; y -= lowbit(y))

这个太二了。。不解释。。一维这么写没关系。。二维就真的2b了。。。果断开个新变量啊少年，省代码会死啊。。。
还有初始化要用-inf。因为会有负数出现。

代码附在这里：

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 102
const int inf = ~0u >> 1;
int n,m,tr[maxn][maxn],dp[maxn][maxn],map[maxn][maxn];
int bit(int x){return x & -x;}
struct node
{
    int x,y,val;
    node(){}
    node(int _x,int _y,int _val):x(_x),y(_y),val(_val){}
}no[maxn * maxn];
int ab(int x)
{return (x > 0)?x:-x;}
bool operator < (const node &a,const node &b)
{
    return a.val > b.val || (a.val == b.val && a.x > b.x) || (a.val == b.val && a.x == b.x && a.y > b.y);
}
void init()
{
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= m;j++)
            tr[i][j] = -inf;
}
void mod(int x,int y,int val)
{
    for(int i = x;i <= n;i += bit(i))
        for(int j = y;j <= m;j += bit(j))
            if(tr[i][j] < val)
                tr[i][j] = val;
}
int find(int x,int y)
{
    int ans = -inf;
    for(int i = x;i > 0; i -= bit(i))
        for(int j = y;j > 0;j -= bit(j))
            if(ans < tr[i][j])
                ans = tr[i][j];
    return ans;
}
int main()
{
    while(scanf("%d %d",&n,&m) == 2)
    {
        int cnt = 0;
        init();
        for(int i = 1;i <= n;i++)
            for(int j = 1;j <= m;j++)
            {
                scanf("%d",&map[i][j]);
                no[cnt++] = node(i,j,ab(map[i][j]));
            }
        sort(no,no + cnt);
        for(int i = 0;i < cnt;i++)
        {
            int x = no[i].x,y = no[i].y;
            int temp = find(x,y);
            if(temp == -inf)
                dp[x][y] = map[x][y];
            else
                dp[x][y] = map[x][y] - temp;
            mod(x,y,dp[x][y]);
        }
        int ans = -inf;
        for(int i = 1;i <= n;i++)
            for(int j = 1;j <= m;j++)
                if(ans < dp[i][j])
                    ans = dp[i][j];
        printf("%d\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-07-31 12:14 发表评论

HDU 3899 JLUCPC ［树形DP］（好多坑爹之处）

BUPT-[aswmtjdsj] @ Penalty — Fri, 29 Jul 2011 07:21:00 GMT

摘要: JLUCPC Time Limit: 15000/5000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 233 Accepted Submission(s): 37 Proble... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-29 15:21 发表评论

HDU 3887 Counting Offspring ［DFS序列＋树状数组］

BUPT-[aswmtjdsj] @ Penalty — Wed, 27 Jul 2011 16:47:00 GMT

Counting Offspring

Time Limit: 15000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 423 Accepted Submission(s): 137

Problem Description

You are given a tree, it’s root is p, and the node is numbered from 1 to n. Now define f(i) as the number of nodes whose number is less than i in all the succeeding nodes of node i. Now we need to calculate f(i) for any possible i.

Input

Multiple cases (no more than 10), for each case:
The first line contains two integers n (0Following n-1 lines, each line has two integers, representing an edge in this tree.
The input terminates with two zeros.

Output

For each test case, output n integer in one line representing f(1), f(2) … f(n), separated by a space.

Sample Input

Sample Output

0 0 0 0 0 1 6 0 3 1 0 0 0 2 0

Author

bnugong

Source

2011 Multi-University Training Contest 5 - Host by BNU

题意是，给一棵树，给每个结点一个标号，问所有存在的结点，它的子树中，结点标号小于它的有多少个。

做法：DFS序列构造＋树状数组查询区间。

竟然忘了DFS的遍历的意义。对一棵树进行DFS遍历，一个结点最多到达两次，一次出，一次入，而这之间的结点标号均为它的子树结点的标号。所以只要用某种方法快速查询其左右标号内含的区间中，比它小的标号个数即可。（别＊2）在肖神的提携下，ym到了树状数组在本题的使用方法。

做法流程。初始化（记得树状数组和DFS记录序列要开点数*2的。。因为这个nc半天，不解释。）－>建图－> DFS（因为HDU坑爹的栈大小，必须手写栈模拟DFS才能过。。第一次手工模拟DFS。。太蛋疼了。。调了无数次。）－>对于每个点查询DFS序列。（既然是离线查询，那么就按照从小到大查吧。凡事要有个序，有序了就好查了。对于每个点的标号，先查它的左右区间是否有比它小的sum(r[i] - 1) - sum(l[i]]).....再把它插入树状数组中，插一次就好，不然结果还得除二。（都是肖神！）
T_T。。记得树状数组和dfs序列都是开到点数*2的，而其他的都是点数大小的。注意初始化和树状数组查询和更新时的范围同理。
代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#include <algorithm>
using namespace std;
stack <int> S;
#define maxn 100005
int cnt,p,n,tot,lit[maxn],seq[maxn * 2],l[maxn],r[maxn],tr[maxn * 2];
int bit(int x){return x & -x;}
bool vis[maxn];
struct edge
{
    int p,next;
    edge(){}
    edge(int a,int b):p(a),next(b){}
}v[maxn],e[maxn * 2];
void add(int p,int q)
{
    e[tot] = edge(q,v[p].next);
    v[p].next = tot++;
}
int sum(int x)
{
    int ans = 0;
    for(;x > 0;x -= bit(x))
        ans += tr[x];
    return ans;
}
void mod(int x,int val)
{
    for(;x < cnt;x += bit(x))
        tr[x] += val;
}
void init()
{
    tot = 0;
    for(int i = 1;i <= n;i++)
        v[i].next = -1;
    fill(tr,tr + 2 * n + 1,0);
    fill(vis,vis + n + 1,0);
    while(!S.empty())
        S.pop();
}
void dfs()
{
    cnt = 1;
    S.push(p);
    while(!S.empty())
    {
        int now = S.top();
        if(!vis[now])
        {
            seq[cnt] = now;
            l[now] = cnt++;
            vis[now] = true;
        }
        bool mark = false;
        for(int k = v[now].next;~k;k = e[k].next)
        {
            if(!vis[e[k].p])
            {
                mark = true;
                S.push(e[k].p);
                v[now].next = e[k].next;
                break;
            }
        }
        if(mark)
            continue;
        if(vis[now])
        {
            seq[cnt] = now;
            r[now] = cnt++;
            S.pop();
        }
    }
}
void gao()
{
    for(int i = 1;i <= n;i++)
    {
        lit[i] = sum(r[i] - 1) - sum(l[i]);
        mod(l[i],1);
    }
}
int main()
{
    while(scanf("%d %d",&n,&p) == 2 && (p || n))
    {
        init();
        for(int i = 0;i < n - 1;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            add(a,b);
            add(b,a);
        }
        dfs();
        gao();
        for(int i = 1;i <= n;i++)
        {
            printf("%d",lit[i]);
            putchar((i == n)?'\n':' ');
        }
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-07-28 00:47 发表评论

HDU 3871 Cubic Maze 【Simulation Building Graph + BFS】【废题，不要看了，不知道现在数据改成什么鬼德性了。。这份代码和标程都交不过去了。】

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

摘要: Cubic Maze Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65768/32768 K (Java/Others) Total Submission(s): 14 Accepted Submission(s): 7 Probl... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-07-23 15:57 发表评论

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 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 发表评论

HDU 3269 P2P File Sharing System 【模拟，时间轴做法】

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

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=3269

Source：2009 Asia Ningbo Regional Contest Hosted by NIT J题 稍微有点麻烦的模拟

题目大意：

模拟BT下载的文件传输方式。

直接解释数据：

t组case。

n(n <= 20)台电脑，T(T <= 1000)：模拟过程的总时间（这才是进行模拟的关键轴）。（单位：second）

k表示有k台电脑初始时作为服务器直接提供文件下载，S：下载文件的大小（在模拟过程中只有一个文件可供下载）。（单位：kb）

此行有k个数：表示作为服务器的k台电脑的编号id（或者说标记名称）。

一个n*n的对阵矩阵，matrix[i][j]的值表示编号为i和编号为j的电脑互相之间下载上传速度（带宽不被分享，即恒定），主对角线均为0，因为自身无传输速度。

接下来n行：第i行对应编号为i的电脑，每行第一个数为t，表示第i台电脑有t段在线时间，接下来2t个数，分别表示第t段时间的开始时间点和结束时间点（即第i台电脑的上线时间和下线时间，时间段为左闭右开，即下线时间点不提供下载上传服务）。

m表示有m次下载操作。（因为每台电脑的下载操作只需执行一次，便会一直在时间轴界限(<=T)内一直执行，又因为没有终止下载操作，所以对于每台电脑来说，最多只会有一个执行操作，所以虽然m未给数据范围，但是显然，m<=n）

m行：每行第一个数表示下载开始时间点t(i)，第二个数表示开始下载的电脑c(i)。

（保证初始为服务器的电脑不会被要求执行下载的命令）

（虽然一台电脑被执行了下载命令，可是若它不在线，也不能下载，只是出于挂起状态，等待上线）

（当某台电脑的文件下载完成度达到100%以后，自动变为服务器，开始上传，不再执行下载操作）

（客户端电脑会从所有服务器同时进行下载）

（因为下载时间是上取整，所以按时间轴模拟的话，最后文件完成度要进行下取整，互逆操作啊~）

#include <iostream>

#include <cstdio>

#include <cmath>

using namespace std;

int n,T,k,S;//机数，时间轴长度，初始服务器数量，文件大小

bool ser[25];//标记某台电脑是否为服务器

int mat[25][25];//传输速度矩阵

int t;//在线时间段数

bool TIME[25][1005];//利用离散化思想通过标记数组记录每台电脑在线时间点

int on,off;

int m;//操作数

bool click[25];//当有下载命令下达时，某台电脑才会变为客户端，该标记数组用以确定某台电脑是否被激活变成进行下载的客户端

struct command//该结构体用以扫描时间标记数组以确定某特定时间点哪一台电脑被激活

{

    int t,c;//表示t时间点第c台电脑被激活

}co[30];

bool com[1005];//所谓时间标记数组，用以记录时间轴上哪一点有激活操作发生

int cont[25];//某台电脑上“关键文件”的剩余需下载量（初始为S，服务器为0）

void solve()

{

    scanf("%d%d",&n,&T);

    scanf("%d%d",&k,&S);

    for(int i = 1;i <= n;i++)//初始化时间轴

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

            TIME[i][j] = 0;

    for(int i = 0;i <= T;i++)//初始化时间标记数组

        com[i] = 0;//command seq init

    for(int i = 1;i <= n;i++)//各种init

    {

        ser[i] = 0;

        cont[i] = S;

        click[i] = 0;

        co[i].t = -1;//时间轴从0开始，将命令操作初始存在时间改为-1以防WA

    }

    for(int i = 1;i <= k;i++)//which is server

    {

        int a;

        scanf("%d",&a);//确定初始服务器

        ser[a] = 1;

        cont[a] = 0;//规范化服务器的文件剩余量

    }

    for(int i = 1;i <= n;i++)//trans velocity to each other

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

            scanf("%d",&mat[i][j]);//读入矩阵

    for(int i = 1;i <= n;i++)//读入第i台电脑的在线时间段

    {

        scanf("%d",&t);//t segments

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

        {

            int a,b;

            scanf("%d%d",&a,&b);

            for(int z = a;z <= b - 1;z++)

                TIME[i][z] = 1;//离散化思想储存第i台的在线时间点

        }

    }

    scanf("%d",&m);//m operation.

    for(int i = 1;i <= m;i++)

    {

        scanf("%d%d",&co[i].t,&co[i].c);//第t时间第c台电脑被激活

        com[co[i].t] = 1;

    }

    for(int i = 0;i <= T;i++)//时间轴上扫描

    {

        //key..judge

        if(com[i] == 1)//如果该时间点有激活操作发生

        {

            for(int j = 1;j <= n;j++)//搜索对应激活操作的是哪台电脑

                if(co[j].t == i)

                    click[co[j].c] = 1;//标记激活

        }

        //handle

        for(int j = 1;j <= n;j++)//第j台电脑

        {

            if(click[j] == 1 && TIME[j][i] == 1 && ser[j] == 0)//已激活，在线，非服务器

            {

                for(int z = 1;z <= n;z++)//扫描所有电脑和第j台电脑的关系

                {

                    if(ser[z] == 1)//如果z是服务器

                    {

                        if(TIME[z][i] == 1)//z在线，i时刻

                        {

                            cont[j] -= mat[j][z];//那么就在i时刻，z传给j，mat[j][z]大小的文件块

                        }

                    }

                }

            }

        }

        for(int j = 1;j <= n;j++)//每秒过后扫描是否有新的电脑变成服务器提供下载，关键！

        {

            if(cont[j] <= 0)

            {

                cont[j] = 0;

                ser[j] = 1;

            }

        }

    }

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

    {

        double rate = (double)(S - cont[i]) * 100 / S;//输出完成度，用下取整（对应题目中上取整）

        printf("%.0lf",floor(rate));

        cout << '%' << endl;

    }

}

int main()

{

    int ca;

    while(cin >> ca){

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

        solve();}

}

//欢迎大牛拍我

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

HDU 3673 David Shopping 【可修改堆】

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

2007 Asia Regional Chengdu D题：David Shopping
原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=3673
涉及算法：可修改堆+标记数组（后者不算算法……请勿鄙视）（大牛们都用STL过的，我手写优先队列。。。。蛋都碎了）

题目大意：
    你有一个能放M(M <= 50000)个物品的容器，你可能会遇到N（N <= 100000)个物品。
    规则：
        1.遇到的物品K你如果之前没有遇到过，且你的容器未满，那么把这个物品（编号K），放进容器中，并记录数字1（相当于权值），且记录遇到该物品的时间t。
        2.遇到的物品K如果在你的容器里，那么仅仅把它的标记数字（即所谓权值+1）。
        3.遇到的物品K你如果之前没有遇到过，且你的容器已满，那么就把容器里标记数字最大的容器移除，如果不止一个，那么就把最先进入容器的那一个移除。（移除的物品就相当于没有遇到过，之后遇到算第一次遇到。）
    求解问题：给你M，N，以及一行数字N个K(i)，（K（i）< 2^20,i = 1 to N)，输出共发生移除操作多少次。（TimeLimit：1s）
算法：
模拟优先队列，实现O(Nlog(M))的时间复杂度的算法。
利用堆的性质，实现插入，删除，维持堆的性质操作均为O(logM)的复杂度。
利用外置标记数组，记录关键值对应元素在书中的位置，类似（计数排序）（或者说哈希表，或者说外部索引数组）的思想。（其实我觉得算是骗过去的。因为空间复杂度O(MAX(K(i)))。。。如果K(i)大一点，内存就爆了。。不过现场赛不卡内存，幸好幸好～

#include <iostream>
#include <cstdio>
#define left(x) (x << 1)
#define right(x) ((x << 1) + 1)
#define parent(x) (x >> 1)
using namespace std;
struct heap
{
    int key,t,w;
} h[50005];//key为物品名K，t为入队时间，w为权值
int now,n,m,cnt,fuck[(1 << 21)],pick[100005];//now：初始插入位置，n,m:respectively，cnt:关键计数器，记录出队次数，f**k数组用于计数排序记录某元素在堆/队列中的位置
void init()//初始化
{
    for(int i = 1;i <= n + 1;i++)
    {
        h[i].key = h[i].w = 0;//堆中元素权值为零
        h[i].t = m + 1;//堆中元素入队时间均为最大时间值+1
    }
}
void make(int i)//保持堆的性质，同时更新外部索引数组(O(h) = O(logM))
{
    int large,l,r;
    l = left(i);
    r = right(i);
    if(l <= n && (h[l].w > h[i].w || (h[l].w == h[i].w && h[l].t < h[i].t)))//同时对权值和时间进行对比，维持性质
        large = l;
    else
        large = i;
    if(r <= n && (h[r].w > h[large].w || (h[r].w == h[large].w && h[r].t < h[large].t)))
        large = r;
    if(large != i)
    {
        int tempp = fuck[h[i].key];//先交换外部索引数组中对应元素的位置，再维护堆的性质，保持实时更新
        fuck[h[i].key] = fuck[h[large].key];
        fuck[h[large].key] = tempp;
        swap(h[i],h[large]);
        make(large);
    }
}
void insert(int key,int p,int t)//插入函数，先插入，通过now记录暂时的初始位置，再用保持堆的性质来维护堆且维护元素位置(O(h) = O(logM)，等价于维护堆性质的复杂度)
{
    h[p].key = key;
    h[p].t = t;
    h[p].w = 1;
    fuck[key] = p;
    make(1);
    now ++;
}
void insert2(int key,int t)//同时实现出队和入队操作。（此时为队列已满的情况）(O(h) = O(logM)，等价于维护堆性质的复杂度)
{
    fuck[h[1].key] = -1;//一句话出队，哇卡卡～
    fuck[key] = 1;
    h[1].key = key;
    h[1].t = t;
    h[1].w = 1;
    make(1);
}
int re(int i)//所谓的权值修护（堆的可修改性）(O(h) = O(logM)，等价于维护堆性质的复杂度)
{
    bool mark = false;
    int p = parent(i);//对于权值增加的堆元素，沿路向上，进行反向堆维护，从而使权值更改的元素达到正确的位置，方便之后重新进行维护堆的性质操作
    if(p >= 1 && (h[p].w < h[i].w || (h[p].w == h[i].w && h[p].t > h[i].t)))
    {
        mark = true;
        int tempp = fuck[h[i].key];
        fuck[h[i].key] = fuck[h[p].key];
        fuck[h[p].key] = tempp;
        swap(h[i],h[p]);
        return re(p);
    }//重新堆维护的起始点，某祖先点，或者该点
    if(mark)
        return p;
    else
        return i;
}
void print()//这脑残函数是用来测试sample的。。帮了我大忙阿。。。其实大神们的调试都是各有风格的，而小菜们的调试，如我，都是类似的。。。
{
    cout << endl;
    for(int i = 1;i <= n;i++)
    {
        printf("h[%d] %d %d %d %d\n",i,h[i].key,h[i].w,h[i].t,fuck[h[i].key]);
    }
}
int FIND(int key){return fuck[key];}//索引查找，一句话函数～
void solve()
{
    now = 1;
    cnt = 0;
    int key,pos,Max = 0;
    init();
    for(int i = 1;i <= m;i++)//缓存读入，查找最大key值元素
    {
        scanf("%d",&pick[i]);
        Max = (Max < pick[i]) ? pick[i] : Max;
    }
    for(int i = 0;i <= Max;i++)//通过key值元素的最大值，开适合大小的索引数组（节省内存和时间）
        fuck[i] = -1;
    for(int i = 1;i <= m;i++)
    {
        key = pick[i];
        pos = FIND(key);//查找是否已入队
        if(pos == -1)//新插
        {
            if(now > n)//已满
            {
                cnt ++;
                insert2(key,i);
            }
            else//未满
                insert(key,now,i);
        }
        else//已有
        {
            h[pos].w ++;
            //WA POINT
            make(re(pos));//可修改堆。。。之前一直忘记了这个根本。。。加了修改权值操作之后就过了。。蛋碎。。。。。
        }
        //print();
    }
    printf("%d\n",cnt);
}
int main()
{
    int CAS = 1;
    while(scanf("%d%d",&n,&m) != EOF && (n || m))
    {
        printf("Case %d: ",CAS++);
        solve();
    }
}

//小菜出品，欢迎大牛拍我。。。。

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

HDU 3471 England vs Germany 【三维线段判定】

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

2010MU（ACM2010多校联合训练）-Fourth-UESTC-C Problem-England vs Germany-Solution Report

前言：这个2B题。谁出的谁自杀去。题目描述和数据还有官方解题报告都对着干。我们这帮做题的情何以堪！？

Description

The big fight between England and Germany was destroyed by the guy called Larrionda. England could have made a tie of 2:2. But that poor guy disqualified Lampard's wonderful goal. The ball passed through the goal line by half a meter, however, Larrionda turned a blind eye to this goal.

As a fan of Three Lion Regimen, silentsky want to develop a system which uses sensors to get the information to check if it scored or not.

The information includes a point as the location of ball, a vector as the velocity and a cuboid as the goal.

译文大意：

三狮军团和德意志战车单挑的时候，裁判拉里昂达2B了。因为拉里昂达的2B，那个完美进球被吹没了，本来有可能打平的比赛变成了日耳曼人屠戮了盎格鲁撒克逊人。

出题的人是个英粉，现在，他想让你编程构建一个系统来确定那个球到底是进还是没进。

所给信息包括，足球起始位置，速度矢量，以及，球门长方体八点。（均为三维坐标）

Input：

The first line gives an integer t (t<=10000) indicating the number of test cases.

For each case:

The first line gives three real numbers x, y , z, indicating a point to represent the ball.

The second line gives three real numbers a, b, c. indicates a vector to represent the velocity.

The following 8 lines give 8 points according the sequence A, B, C, D, E, F, G, H as is shown in the figure.

Absolute value of all real numbers are smaller than 10000.

It is guaranteed that the initial location of the ball is not inside the goal.

译文：

第一行为测试数据组数（小于等于10000的整数）。

第二行是球的坐标。

第三行是速度矢量。

第4~11行是按序给出的A~H八点的坐标。

（以上数据除组数外均为实数）

所有实数的绝对值均小于10000。

确保球的初始位置不在球门内。（这句话是让无数人WA的关键。实际的测试数据中给出了在球门内的数据。）（怎么说呢。是写解题报告和出题的人没有和写标程测试数据的人统一好意见呢。还是根本就没认真对待出题这种神圣的事情，纯粹2B了呢？！）

（自己建的图，特意下载了个AutoCAD2010.花了一个小时玩明白一点点建了个图）

Output：

if it scored then output “Case X: Stupid Larrionda!!!”.otherwise output “Case X: Intelligent Larrionda!!!”.(X is the case number starting from 1).

（We consider ABCD as the front of the goal and AB,BC,CD,DA as the goalposts. A shoot scores if and only if it passes through the front of the goal and doesn't crash on the goalpost)

译文：如果球进了，我们就输出“Case X: Stupid Larrionda!!!”（第X种情况：愚蠢的拉里昂达！！！）否则就输出 “Case X: Intelligent Larrionda!!!”（第X种情况：聪明的拉里昂达！！！）（X从1开始计数）

（我们认为ABCD为球门，AB、BC、CD、DA为球门框，球进了的意思是，球从球门穿过并且未触碰到球门框。）

（可是扯淡的地方在于，门线竟然被当做了球门，我们很无奈，但是要尊重题意（去你妈的题意），没办法，还是把门线当做了门框。

这道题的关键就在于判断球是否从球门进入，而非从侧面或者背面或者上下面进入。）

（但是因为，球在球门内向球门里射这种情况的存在，使这道经典计算几何练习题变成了ws的扯淡题。下面将提到。）

Sample Input：

20 0 5

-10 5 0

10 0 10

10 10 10

10 10 0

10 0 0

0 0 10

0 10 10

0 10 0

0 0 0

（模拟图在上面）

Sample Output：

Case 1: Stupid Larrionda!!!

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3471

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <algorithm>
#include <vector>
#define MAX 1<<30
using namespace std;
const double eps=1e-8;
typedef long long ll;
int main()
{
    typedef struct
    {
    double x;
    double y;
    double z;
    } plus; //三维点坐标的结构。。话说有没有这样的STL啊？
    plus r[100],xa[100],p[100];

//下面是我比赛的时候去恶补的高数知识。。下学期高数没学好啊。几何部分一窍不通。泪目。。。
   /* 面法向量（本题中简易做法是AEvector)

   * 本题中因为给出的是严格长方体，所以ABCD面法向量就是AEvector

   * 下面的法向量求法就没用了，不过学会了更好，我这个数学2B
   * x0=(y2-y1)*(z3-z1)-(z2-z1)*(y3-y1),
   * y0=(z3-z1)*(x2-x1)-(x3-x1)*(z2-z1),
   * z0=(x2-x1)*(y3-y1)-(x3-x1)*(y2-y1)
   * x0*(x-x1)+y0(y-y1)+z0(z-z1)=0

   * 直线参数方程是本题中判断球所在位置的关键
   * 直线参数方程 (p为始点,f为末点，即交点)
   * xf=xp+mt
   * yf=yp+nt
   * zf=zp+qt

   * 以下为求参数方程中t的关键
   * 线面相交方程
   * x0*(xp+mt-x1)+y0*(yp+nt-y1)+z0*(zp+qt-z1)=0
   * (x0*m+y0*n+z0*q)t=(x1-xp)*x0+(y1-yp)*y0+(z1-zp)*z0
   * 参数解法（即，交点确定方法） */

   //  freopen("eg.in","r",stdin);
   //  freopen("fuck3.out","w",stdout);
   int t,i,j,k,ca=0;
   double temp[6],pp[100];//,r[4],l;
   plus o,v,m,f;
   scanf("%d",&t);
   while(t--)
   {
    scanf("%lf%lf%lf",&o.x,&o.y,&o.z);
    scanf("%lf%lf%lf",&v.x,&v.y,&v.z);
    printf("Case %d: ",++ca);
    for(i=0;i<8;i++)
     scanf("%lf%lf%lf",&p[i].x,&p[i].y,&p[i].z);
    m.x=p[4].x-p[0].x;
    m.y=p[4].y-p[0].y;
    m.z=p[4].z-p[0].z; //AEvector

    //将AEvector与速度矢量进行点积，判断速度与法向量是否同向

    //从而判断球是否射向球门内
    if(m.x*v.x+m.y*v.y+m.z*v.z<=eps)
     {
      printf("Intelligent Larrionda!!!\n");
      continue;
     }

    //求由球点与速度矢量确定的直线方程与ABCD及EFGH面的交点

    //temp[0]为与ABCD的交点的参数t的值

    //temp[1]为与EFGH的交点的参数t的值
    temp[0] =( (p[0].x-o.x)*m.x+(p[0].y-o.y)*m.y+(p[0].z-o.z)*m.z )/(m.x*v.x+m.y*v.y+m.z*v.z);
    temp[1] =( (p[4].x-o.x)*m.x+(p[4].y-o.y)*m.y+(p[4].z-o.z)*m.z )/(m.x*v.x+m.y*v.y+m.z*v.z);

    /*判断球是否在球网EFGH的后面

    * 本来我只判断了球是否在球门之后，毕竟题目里说了球初始点不可能在球门内

    * 可是我事后去翻看了标程以及标程数据生成器，果然有这样的数据存在

    * 所以一开始sunyuqi和linyiyong同学竟然能把这道题过了，我表示非常震惊

    * 他们这叫歪打正着呢？还是有先见之明？

    * 学长们，以及我，都被那组不符合题意的数据卡死了。10+的WA。光辉的一B啊！

    * 1W组数据中的100组。被那2B的标程搞死。NND。

    */
    if(temp[0]<=eps&&temp[1]<=eps)
     {
      printf("Intelligent Larrionda!!!\n");
      continue;
     }

    //前面一路判断都为真的话，则求ABCD与射球轨迹的交点
    f.x = o.x + temp[0]*v.x;
    f.y = o.y + temp[0]*v.y;
    f.z = o.z + temp[0]*v.z;

    /*

    * 现在判断交点是否在ABCD面内

    *（严格内部，而非在这个平面上，但不在所包围的区域内）

    * 想法是，求出FAvector，FBvector，FCvector，FDvector（交点在F）

    * 再顺时针对这四个矢量求叉积，叉积即该平面（ABCD）的一侧法向量

    * 再判断这四个法向量是否在同侧即可

    * 判断方法为这四个叉积所得向量进行顺时针点积。均为正，则同向。

    */
    for(i=0;i<4;i++)
    {
     r[i].x = p[i].x - f.x;
     r[i].y = p[i].y - f.y;
     r[i].z = p[i].z - f.z;
    }
    for(i=0;i<3;i++)
    {
     xa[i].x= r[i+1].z*r[i].y-r[i+1].y*r[i].z;
     xa[i].y= r[i+1].x*r[i].z-r[i+1].z*r[i].x;
     xa[i].z= r[i+1].y*r[i].x-r[i+1].x*r[i].y;
    }
    xa[3].x=-( r[3].z*r[0].y-r[3].y*r[0].z);
    xa[3].y=-( r[3].x*r[0].z-r[3].z*r[0].x);
    xa[3].z=-( r[3].y*r[0].x-r[3].x*r[0].y);
    for(i=0;i<3;i++)
     {
      if(xa[i].x*xa[i+1].x+xa[i].y*xa[i+1].y+xa[i].z*xa[i+1].z>0);
      else
       {printf("Intelligent Larrionda!!!\n");break;}
     }
     if(i==3)
      printf("Stupid Larrionda!!!\n");
   }
   //  system("pause");
   //   fclose(stdin);
   //  fclose(stdout);
   return 0;
}
/* 本题，我中间错了无数次。

* 算法一改再改，从一开始判断球与球门的相对位置时计算点面距离，到中间的通过叉积矢量xyz坐标单纯相加判断是否同向，本人对高数以及计算几何进行了各种各样的练习。

* 这还不算上，对于测试文件输入输出的学习，对于标程与自己程序对拍方法的学习。

* 这道题消耗了我一天的时间，但是我觉得值，因为我深入理解了这个问题。虽然不代表我以后遇到这类问题能照AC不误，但至少，我从中收获了不少东西。

* 顺便鄙视一下某些出题人。

* 另外，本人的队友sunyuqi同学，做这题时运用了三维矩阵坐标变换的方法，鉴于本人线性代数超烂，故没学会，也就不摆上来献丑了。等以后学会了再来研究一下不迟。

* 第一次写解题报告，如有错误，烦请指正。

* 感谢各位百忙之中浏览本文。

*/

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

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

HDU 2297 Run 【半平面交 or 维护单调性】

Chengdu Regional 2008［被虐爆了，留个记号］

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

HDU 4024 Dwarven Sniper’s hunting【水二分】

HDU 4022 Bombing【STL 继续练习】

HDU 3212 Card Collection【两个虚拟根或者一个】 && HDU 2121 Ice_cream’s world II 【不定根的最小树形图】

HDU 4009 Transfer water 【最小树形图】

HDU 4007 Dave 【双扫描线暴力】

HDU 4006 The kth great number 【STL 使用练习】

HDU 3986 & HDU 3987 & HDU 3991 【多校第十五场WHU 三道模板题】

HDU 3972 1M Possible 【乱搞】

HDU 3961 Crisis【恶心的几何模拟】

HDU 3955 March【读题困难的BFS/PFS】

HDU 3931 Cross the Fire ［陈题，无向图最小权点割］

Cross the Fire

HDU 3927 Math Geek 【这你妹的乱搞】

HDU 3912 Turn Right 【水题 模拟搜索】

Turn Right

HDU 3917 Road constructions【最大权闭合子图 脑抽的建图】

Road constructions

HDU 3883 CS and Sugar ［DP 以序消除后效性 树状数组快速统计］

CS and Sugar

HDU 3899 JLUCPC ［树形DP］（好多坑爹之处）

HDU 3887 Counting Offspring ［DFS序列＋树状数组］

Counting Offspring

HDU 3871 Cubic Maze 【Simulation Building Graph + BFS】【废题，不要看了，不知道现在数据改成什么鬼德性了。。这份代码和标程都交不过去了。】

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 1985 Cow Marathon & HDU 2196 Computer 【简单树形dp - 树的直径】

HDU 3269 P2P File Sharing System 【模拟，时间轴做法】

HDU 3673 David Shopping 【可修改堆】

HDU 3471 England vs Germany 【三维线段判定】

HDU 3912 Turn Right 【水题模拟搜索】

HDU 3917 Road constructions【最大权闭合子图脑抽的建图】

HDU 3883 CS and Sugar ［DP 以序消除后效性树状数组快速统计］

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