O興~ http://imlazy.ycool.com/ Sat, 04 Jul 2009 11:07:19 GMT Sat, 04 Jul 2009 11:07:19 GMT http://sta.yculblog.com/images/logo/general-88x31.gif O興~ http://imlazy.ycool.com/ 在跆拳道馆遇到温喜庆了 http://imlazy.ycool.com/post.2443157.html
    因为学校放暑假，跆拳道社团停了，我也就没处可锻练了。自从去年受伤以后，我也没有去过原来在宝山的那家道馆了。那里后来换了个韩国教练，我也不好交流了。而且那里的小孩太多了，不适合我。

    一直想找一家成人多一点的道馆，以后工作了就去那里练。可是现在社会上大多数的道馆都是儿童补习班性质的，全是小孩，完全变了味了。

    上星期，在实习的公司附近找到了一家武馆，是学校社团的教练推荐的。本来不抱有太大希望，只是去看看。谁知那里的气氛很好。虽然场地不是很大，环境很朴素，但是那里的人都很有激情，而且大多数是成人，我和想象中的、影视剧里那样的道馆很像。而且不仅有跆拳道，拳击、武术等等各种项目的人都在一起练习，各自在自己的区域，但是互相之间没有隔离开。

    最有趣有就是，温喜庆也在那里练拳击。可见这家武馆真的不错，连名人都认可了它。而且价格一点也不贵，我两天工资就能交一个暑假的学费了。我想我以后会一直去那里练习的，如果我能继续在第一资讯或者周围上班的话。

    不过这家武馆的名字我不能说，不然就泄露了名人的隐私了。

    锻练身体之余，不免要担心一下我的论文。由于种种原因，进度很慢。我确实是个爱磨蹭的人。

    最后顺便说一下，今天公司组织我们去看《变形金刚2》，我觉得真好看。不了解变形金刚的人看了可能会累，但是金刚迷一定会觉得很爽。... ]]> http://imlazy.ycool.com/post.2443157.html Sat, 04 Jul 2009 10:07:20 GMT 跆拳道 温喜庆 报告一下我的近况吧 http://imlazy.ycool.com/post.2351158.html
    在工作日的午饭吃得都很好；晚上回家以后妈妈也给我供了一大堆吃的，所以自从去年底长胖了以来，一直没瘦下去。幸亏我每周还有两天可以在学校自己合理饮食、练两次跆拳道。

    昨天公司的同事们组织了去南北湖春游。风景真的是不怎么样；但是如果只是当作到大自然里去散散步、聊聊天的话，还是不错的。

    发一张我的照片吧。飞行棋T恤好帅啊。

... ]]> http://imlazy.ycool.com/post.2351158.html Sun, 17 May 2009 05:05:31 GMT 如果这样下去，我可能没法再写 BLOG 了 http://imlazy.ycool.com/post.2267854.html
    把这一年熬过去，八小时之外我就自己撑握了。盼啊～... ]]> http://imlazy.ycool.com/post.2267854.html Wed, 11 Feb 2009 12:02:05 GMT 实习 ACM-ICPC 2008 杭州赛区第 C 题，Cryptography Reloaded http://imlazy.ycool.com/post.2261251.html 这道题目要求跟据 RSA 加密算法中的 n、 e 和 d 求出 p 和 q。其中 n = pq；e 和 d 互为 MOD (p - 1)(q - 1) 情况下的逆元，即 ed MOD (p - 1)(q - 1) = 1；p < q；n, d ≤ 10100； 3 ≤ e ≤ 31。

    我记得比赛时有不少队做出了这道题，可是我们毫无头绪。以下是 PROXIMA 队的做法。

    已知 ed - 1 是 (p - 1)(q - 1) 的倍数，则可以枚举可能的 (p - 1)(q - 1) 值。他们枚举了 ed - 1、(ed - 1) / 2……直到 (ed - 1) / 100。

    然后设 t = (p - 1)(q - 1)，n = pq，则可以解出 p 和 q：
  • p =
  • q =
    只要碰到中间过程整除都除得尽、根号都开得出的，就是答案了。这么说起来好像一点也不难，我们怎么就是想不出呢，主要还是被大数吓到了。以下是 PROXIMA 队的代码，其中第 61 ~ 80 行重复了两遍，我没看出这有什么作用： 


import java.io.FileInputStream;
import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author acm
 */
public class Main {

    public static BigInteger sqrt(BigInteger a) {
        double ad = a.doubleValue();
        ad = Math.sqrt(ad);
        BigInteger l = BigInteger.valueOf(0);
        BigInteger r = new BigInteger(a.toString());
        /*double size = Math.log10(a.doubleValue());
        if (size)*/
        while (l.compareTo(r)<0) {
            BigInteger mid = l.add(r).divide(BigInteger.valueOf(2));
            int res = mid.multiply(mid).compareTo(a);
            if (res==0) return mid;
            if (res<0) l = mid.add(BigInteger.ONE);
            else r = mid.subtract(BigInteger.ONE);
        }
        return l;
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
/*        BigInteger a1 = BigInteger.probablePrime(100, new Random());
        BigInteger a2 = BigInteger.probablePrime(100, new Random());
        BigInteger d = BigInteger.probablePrime(199, new Random());
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a1.multiply(a2));
        System.out.println(d);
        System.out.println();
  */      
        try {
            Scanner in = new Scanner(new FileInputStream("c.in"));
            for (int tt=1;; tt++) {
                BigInteger n = in.nextBigInteger();
                BigInteger d = in.nextBigInteger();
                int e = in.nextInt();
                if (e==0) break;
                
                d = d.multiply(BigInteger.valueOf(e)).subtract(BigInteger.ONE);
                for (int kk=1; kk<=100; kk++) {
                    BigInteger t = d.divide(BigInteger.valueOf(kk));
                    if (t.multiply(BigInteger.valueOf(kk)).equals(d)) {
                        BigInteger tosqrt = n.subtract(t).subtract(BigInteger.ONE).pow(2).subtract(t.multiply(BigInteger.valueOf(4)));
                        if (tosqrt.compareTo(BigInteger.ZERO)>=0) {
                            BigInteger sol = sqrt(tosqrt);
                            if (sol.pow(2).equals(tosqrt)) {
                                BigInteger x = n.subtract(t).subtract(BigInteger.ONE).add(sol).divide(BigInteger.valueOf(2));
                                BigInteger y = n.subtract(t).subtract(BigInteger.ONE).subtract(x);
                                BigInteger p = x.add(BigInteger.ONE), q = y.add(BigInteger.ONE);
                                if (p.signum()>0 && q.signum()>0 && p.multiply(q).equals(n) && p.isProbablePrime(100) && q.isProbablePrime(100)) {
                                    if (p.compareTo(q)>0) {
                                        BigInteger sw = p; p = q; q = sw;
                                    }
                                    System.out.println("Case #"+tt+": "+p+" "+q);
                                    break;
                                }
                                x = n.subtract(t).subtract(BigInteger.ONE).subtract(sol).divide(BigInteger.valueOf(2));
                                y = n.subtract(t).subtract(BigInteger.ONE).subtract(x);
                                p = x.add(BigInteger.ONE); q = y.add(BigInteger.ONE);
                                if (p.signum()>0 && q.signum()>0 && p.multiply(q).equals(n) && p.isProbablePrime(100) && q.isProbablePrime(100)) {
                                    if (p.compareTo(q)>0) {
                                        BigInteger sw = p; p = q; q = sw;
                                    }
                                    System.out.println("Case #"+tt+": "+p+" "+q);
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
... ]]> http://imlazy.ycool.com/post.2261251.html Sat, 31 Jan 2009 05:01:00 GMT acm 杭州 icpc 杭电 杭州电子科技大学 《非诚勿扰》中的风景很漂亮 http://imlazy.ycool.com/post.2257126.html 非诚勿扰》这个电影有一个很大的亮点，那就是当中有很多风景很漂亮。





















... ]]> http://imlazy.ycool.com/post.2257126.html Thu, 22 Jan 2009 14:01:31 GMT 非诚勿扰 2008-12-07，东华蝉联好动杯 http://imlazy.ycool.com/post.2247061.html
    很遗憾的是当时我的腰伤还没好（到现在还是没完全好），没法参加团体特技比赛，只能参加个人品势。本来我是奔着冠军去的，可是中途输给别人了。有一定偶然性，但是个人水平也是因素之一，而且前一个月养伤养胖了许多。还好社长 ZLY 同学帮我报了仇，得了冠军。



个人品势比赛

社长 ZLY，男子个人品势冠军

    最后的团体特技比赛是我们的强项。最终我们的各项总分也得到了第一，蝉联了好动杯。



忘了是谁的腾空八字了

JLM 腾空三前踢

PY 单腿旋风踢


SXQ 后空翻

PH 飞人后踢

YSY 飞人侧踢


东华跆拳道社团部分社员


    另外，我学到了一个教训，就是抓拍运动的东西的时候，不要吝惜把感光度调高；一定要保证曝光时间够短，否则只会像这次一样，人都糊掉了。... ]]> http://imlazy.ycool.com/post.2247061.html Tue, 13 Jan 2009 06:01:02 GMT 跆拳道 东华 好动杯 记昨天在 FIRST DATA 的面试 http://imlazy.ycool.com/post.2234518.html
    衣服令我很尴尬。他们来学校宣传的时候，说衣服要正式，不可以穿牛仔裤。结果我到了那一看，明明都是运动鞋牛仔裤。如果有下次去，我肯定不会穿成这样了。

    公司位于淮海中路香港新世界大厦的 39 楼，我也是第一次从这个高度俯瞰大上海，真大。

    我感觉，这个公司的情调还是很资产阶级的。我想一是因为它是美国的大公司；二是因为它本身就是为银行做支付系统之类的，客户都是知名大银行，所以钞票的味道是很重的。里面有很多老外和港台人，要养这群人，钞票肯定是不能少的。

    我发觉在近一段时间，小资思想在我心中萌芽，居然被这种单位所吸引，有点背离了我当初只是想要玩电脑的淳朴的职业理想。但是还好，即使在这个单位，我还是做软件的，还是搞技术的。

    让我回忆一下面试内容吧。首先是笔试，很简单：
  • 由于出现了一些技术问题，项目要延期交付了。用英文写一封 EMAIL，向客户说明情况。
  • 一些智力题。
    然后是谈话，我记得问了我如下问题：
  • 谈谈对公司的了解
  • 自我介绍一下
  • JAVA
    • InputStream 和 InputStreamReader 有什么区别
    • 虚函数有什么用
    • 函数重载算不算多态
    接下来问了我一些实际的问题：
  • 如果系统在客户那边突然不能工作了，该怎么办？
        我只说了我会用什么方法去找出故障的所在，可是他说最先要做的应该是弄一个应急的方案，让系统能工作起来，这一点我没想到。
  • 目前公司所用的技术是我没有接触过的领域，我该怎么入手？
        我想这个问题是针对我的，因为我确实没什么经验。我当然只能回答虚心请教，积极学习之类的，我还能回答什么呢。
  • 如果在工作中发现公司现有的产品有不足之处，但是也能用，可改可不改，那我会怎么做？
        我说如果有空的话还是会积极向上级请示，要不要让我来改改看。我觉得我这个回答他还是满意的。
    接下来是老外和我谈话：
  • 自我介绍一下
  • 讲讲自己的兴趣爱好
  • 要做一个象棋的程序，我会有哪些步骤？
        我是往人工智能方面说的，说我会搜集大量棋局的资料，这当中可能需要一些启发式的搜索。可是后来我才知道他是想让我从软件工程的角度说说有哪些步骤，需求分析啦，设计啦，写文档啦，测试啦……之类的。看来这个问题我没有回答好。
    老外的话我不是全都能听懂，只是七八分知道他讲的是什么。我说的时候也经常不知怎么表达，看来我的英文对话能力是需要提高的。

    就是这样了，感觉不好也不坏。... ]]> http://imlazy.ycool.com/post.2234518.html Tue, 30 Dec 2008 10:12:18 GMT 面试 第一资讯 first data ACM-ICPC 2008 杭州赛区第 D 题，Déjà vu http://imlazy.ycool.com/post.2234430.html     这道题目是这样的，有起始状态 S 和目标状态 T，它们都是 N 位二进制数（3 ≤ N ≤ 20）；又有 M 个不同的开关（M ≤ C_N^3），分别都是 N 位二进制数，并且每个开关中都恰好有 3 个 1；从 S 开始，每一步状态转换都是与一个开关进行异或（以下用“⊕”表示）；问是否可能到达状态 T，如果可能，至少需要几步。

    代码 1 是 PROXIMA 队这题的代码，好像是楼天成打的。虽然他们在比赛当场 AC 了，可是这个代码现在提交到 HDOJ 上是超时的。因为楼天成做了一件画蛇添足的事，在代码 1 的第 123 ~ 132 行，他判断了输入当中是否有重复的开关。实际上是没有这种输入的。去掉这一段的话，就可以在 HDOJ 上 AC 了。

#include <stdlib.h>
#include <cstdio>
#include <string>
#include <set>

using namespace std;

#define two(X) (1<<(X))

const int maxn=20;
const int maxm=2000;
const int maxsize=two(maxn);

#define two(X) (1<<(X))
#define contain(S,X) (((S)&two(X))>0)

int n,m;
int S[maxm];
int src,dest,state;
int A[maxn+5][maxm];
int side[maxsize];
int Q[2][maxsize],op[2],cl[2];
int RD[maxn+5];

int countbit(int n)
{
    return (n==0)?0:(1+countbit(n&(n-1)));
}
int solve()
{
    if (state==0) return 0;
//    printf("HERE\n");
    for (int i=1;i<=n;i++)
    {
        int k=1;
        for (;k<=m && A[i][k]==0;k++);
        if (k>m)
        {
            if (A[i][0]==1) return -1;
            continue;
        }
        for (int j=i+1;j<=n;j++) if (A[j][k]==1)
            for (int v=0;v<=m;v++)
                A[j][v]^=A[i][v];
    }
    int base=0;
    while (RD[countbit(state)]>5 && m>=50)
    {
        int k=-1;
        for (int i=1;i<=m;i++)
        {
            int newstate=state^S[i];
            if (RD[countbit(newstate)]==RD[countbit(state)]-1)
            {
                k=i;
                break;
            }
        }
        if (k<0) break;
        base++;
        state=state^S[k];
    }
    op[0]=op[1]=0;
    cl[0]=cl[1]=1;
    memset(side,255,sizeof(side));
    Q[0][++op[0]]=0;
    side[0]=0;
    Q[1][++op[1]]=state;
    side[state]=1;
    for (int D=1;1;D++)
    {
      //  printf("%d %d %d\n",D,op[0],op[1]);
        int s=D%2;
        for (int tmp=op[s];cl[s]<=tmp;cl[s]++)
        {
            int set=Q[s][cl[s]];
            for (int i=1;i<=m;i++)
            {
                int newset=set^S[i];
                if (side[newset]==s) continue;
                if (side[newset]<0)
                {
                    side[newset]=s;
                    Q[s][++op[s]]=newset;
                }
                else
                    return D+base;
            }
        }
    }
    return -1;
}
int main()
{
/*    freopen("d.in","w",stdout);
    n=20;
    printf("%d %d\n",n,n*(n-1)*(n-2)/6);
    printf("%d %d\n",0,two(n)-1);
    for (int i=0;i<n;i++) for (int j=i+1;j<n;j++) for (int k=j+1;k<n;k++)
        printf("%d\n",two(i)|two(j)|two(k));
    printf("0 0\n");
    return 0;
 */
    freopen("d.in","r",stdin);
    for (int i=0;i<maxn+5;i++) RD[i]=1000000;
    RD[0]=0;
    for (int step=0;step<maxn+5;step++)
        for (int i=0;i<maxn+5;i++)
            for (int d=-3;d<=3;d+=2)
            {
                int j=i+d;
                if (j>=0 && j<maxn+5 && RD[i]+1<RD[j])
                    RD[j]=RD[i]+1;
            }
    int caseId=0;
    while (scanf("%d%d",&n,&m)!=-1 && n!=0)
    {
        caseId++;
        printf("Case #%d: ",caseId);
        scanf("%d%d",&src,&dest);
  //      printf("%d %d %d %d\n",n,m,src,dest);
        state=src^dest;
        set<int> M;
        M.clear();
        for (int i=1;i<=m;i++)
        {
            int value=0;
            scanf("%d",&value);
            M.insert(value);
        }
        m=0;
        for (set<int>::iterator it=M.begin();it!=M.end();++it) S[++m]=*it;
      //  printf("m = %d %d\n",m,state);
        for (int i=1;i<=n;i++)
        {
            A[i][0]=(int)contain(state,i-1);
            for (int j=1;j<=m;j++)
                A[i][j]=(int)contain(S[j],i-1);
        }
    //    printf("m = %d %d\n",m,state);
        int ret=solve();
        if (ret<0) printf("Impossible\n");
        else printf("%d\n", ret);
    }
    return 0;
}

代码 1

   他们的算法基本上还是双向 BFS。但是在这个问题中，状态空间很大，最多有 220 种；每一步的分枝也很多，最多有 C_{20}^3 = 6840 种开关可选；因此直接开始搜的话就会超时。对此，楼天成做了以下三个重要的优化。

    首先，他对状态 S 和 T 做了转换，S 变成 S ⊕ T，T 变成 0，在代码 1 的第 122 行。这样与原问题是等价的。因为原问题是要把 S 变成和 T 一样，也就是要把 S 的不同于 T 的那几位都取反；而经过转换后的 S，只有在原来 S 和 T 不同的那几位上是 1，现在的目标就是要把这些 1 消掉，让 S 变成全 0。

    经过这一转化，使问题的逻辑简化了不少，也为后面的优化做了铺垫。

    接下来，在代码 1 的第 33 ~ 45 行，他基于定理 1 快速地判断出了是否有解。

(1) 如果所有开关的第一位都是 0，而 S 的第一位是 1，则无解。

(2) 如果所有开关和 S 的第一位都是 0，则说明在本问题中，第一位是是没有任何作用的。现在可以把问题转化，把 S 和所有开关的第一位都 “砍掉”，也就是都变成 N - 1 位。得到的新问题的可解性和原问题相同。

(3) 如果存在第一位是 1 的开关，则把问题进行如下转换，转换得到的新问题的可解性与原问题相同。
  • 任取一个第一位为 1 的开关，称它为 x。
  • 对于 x 除外的每个开关 y，如果它的第一位也为 1，则把它变成 y ⊕ x。
  • 如果 S 的第一位为 1，同样，也把它变成 S ⊕ x。
  • 把 x 从开关的集合中去掉。
  • 把 S 和所有开关的第一位都 “砍掉”，变成 N - 1 位。
(4) 如果 S 被转化为空，则有解。

定理 1

    要证明定理 1，需要借助几个基本的事实：
  • 异或运算满足交换率和结合率。
  • 异或同一个值偶数次，等于什么都没做。
  • 异或同一个值奇数次，等于只异或了一次。
    现在看定理 1 的第 (3) 点。如果存在一组开关，是原问题的一个解，且 S 的第一位为 0，则由于 S 的第一位最终必须仍是 0，这个解一定包含偶数个第一位为 1 的开关。在这偶数个开关中，如果包含 x （可以假设只包含一个 x，因为拿任何开关异或一次以上都是没有意义的），则从这个解当中把 x 去掉，就成了新问题的一个解。因为在这个解当中，x 除外的奇数个第一位为 1 的开关在新问题中都 “附带” 了一个 x，所以在新的解当中，x 出现了奇数次，相当于出现了一次，因此新的解等价于原解。

    对于 x 不包含在原解当中，或者原 S 的第一位为 1，或者原问题无解的情况，证明的方法都是完全类似的，我就不赘述了。

    最后一个优化在代码 1 的第 47 ~ 62 行。内容很简单，是一个贪心，如果 S 包含的 1 的个数比较多，并且可选的开关比较多的话，则只要碰到任何一个开关能使 S 更接进 0，就把它包含到最优解当中去。所谓的 “更接进 0”，需要靠数组 RD 来判断。它是在代码 1 的第 105 ~ 114 行初始化好的，值为 {0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7, 6, …}。RD[11] = 5 的含义为，如果 S 包含 11 个 1，则至少需要 5 步才能把 S 变成 0。

    我想，代码 1 的第 47 行中的 “5” 和 “50” 这两个值是跟据经验指定的。我记得听到楼天成在赛后对别人说，他有一题的算法是错的；周源也说有一个参数改小了就 WRONG ANSWER，改大了就超时，折中一点就 AC 了；我估计他们说的就是这里。无论如何，这样也能 AC，就是牛bility。... ]]> http://imlazy.ycool.com/post.2234430.html Tue, 30 Dec 2008 07:12:27 GMT acm 杭州 icpc 杭电 杭州电子科技大学 ACM-ICPC 2008 杭州赛区第 F 题，Fire-Control System http://imlazy.ycool.com/post.2234422.html 这道题目要求对于平面上的 N 个点（1 ≤ N ≤ 5,000），找出一个以点 (0, 0) 为圆心的扇形，使其能覆盖其中至少 K 个点（K ≤ N），并且该扇形的面积要最小。

    我想这个算法很容易想到，枚举即可。因为对于最小的扇形，它的弧和两条边上肯定都至少覆盖了一个点。所以枚举半径，对于每个半径，把扇形的两条边扫一圈，即可达到 O(N2) 的复杂度（两条边一起扫一圈是 O(N) 的复杂度，可不是 O(N2) 哦）。

    代码 1 是 PROXIMA 队的代码，从风格上看，好像不是楼天成写的。

#include <vector>
#include <algorithm>
using namespace std;
#include <stdio.h>
#include <string.h>
#include <math.h>

FILE *Fin = fopen("f.in","r");
FILE *Fou = stdout;

#define maxn 5100
int p[maxn][2];
int n,m;

struct Point
{
    int r;
    double d;
} q[maxn+maxn];
bool operator < (Point a, Point b) { return a.d<b.d; }
const double PI = atan2(0,-1.0);

inline int hypot2(int a, int b) { return a*a+b*b; }

int main()
{
    int tt=0,i,j,k;
    while (fscanf(Fin,"%d%d",&n,&m)!=EOF)
    {
        tt++;
        if (n==0) break;
        for (i=0; i<n; i++)
        {
            fscanf(Fin,"%d%d",p[i],p[i]+1);
            q[i].r = hypot2(p[i][0], p[i][1]);
            q[i].d = atan2((double)p[i][1], (double)p[i][0]);
        }
        if (m==0||m==1)
        {
            fprintf(Fou,"Case #%d: 0.00\n",tt);
            continue;
        }
        for (i=0; i<n; i++)
        {
            q[n+i] = q[i];
            q[n+i].d += PI+PI;
        }
        sort(q, q+n+n);
        double best = 1e100;
        for (i=0; i<n; i++)
        {
            int l = 0, r = -1, c = 0;
            for (j=0; j<n+n; j++) {
                if (q[j].r<=q[i].r) {
                    c++;
                    if (c==m) {
                        r = j;
                        break;
                    }
                }
            }
            if (r!=-1) {
                c--, r--;
                for (j=r+1; j<n+n; j++) {
                    if (q[j].r<=q[i].r) {
                        c++;
                        while (q[l].r>q[i].r) l++;
                        if (c>m) {
                            c--;
                            l++;
                            while (q[l].r>q[i].r) l++;
                        }
                    }
                    if (j-l+1<=n) {
                        if ((q[j].d - q[l].d) * q[i].r < best)
                            best = (q[j].d - q[l].d) * q[i].r;
                    }
                }
            }
        }
        fprintf(Fou,"Case #%d: %.2lf\n",tt,best/2);
    }
    return 0;
}

代码 1

    我们队在比赛时，最后做的就是这题。TRY 打的代码，可惜一直 WRONG ANSWER。最后我们一起帮他找错误，可惜最终还是没 AC。事后我自己也做了一遍这道题，发现原来它的时间要求还是很严格的，开始我一直超时。后来看了 PROXIMA 的代码，才发现有一些常数级的优化是很有必要的：
  • 两条边扫一圈的时候，最好以点为前进单位，而不要以角度为单位。

        虽然这两种方法是等价的，但是后者需要先把角度相同的点都找出来，还要统计各个角度上分别有几个点，这要花费一些初始化的时间。然而，在最差情况下，每个点所在的角度都可以是不同的，那么以角度为前进单位就完全没有必要了，还白白浪费了初始化的时间。

  • 最好把所有点复制一份，把第二份的所有点的角度都加上 2π。

        也就是说，下标为 0 ~ N-1 的点是第一圈，下标为 N ~ 2N-1 的点是第二圈。这样一来，当扫完了一圈回到开头时，下标不必回到 0，直接走到 N 继续下去就好了。这可以节省很多 MOD 运算的时间。
    然而，我认为代码 1有一个错误，他们是碰巧 AC 的。比如它对数据 1的输出是“15.71”，而我认为答案应该是“17.67”。我觉得问题出在代码 1的第 20 行，给点排序的关键字只有角度，而没有半径；这样，当快速排序后，处在相同角度的点的顺序就会不稳定。而在代码 1 的第 48 行可以看到，第一圈和第二圈的点是放在一起排序的，所以在排序之后，两圈点的相对顺序就有可能不同，最终导致搜索出错。

10 7
-3 0
1 -1
2 -3
-2 0
-1 2
0 3
1 2
2 1
0 -2
-3 -3

数据 1

    不过还是那句话，人家 AC 了就是 AC 了，我们怎么就没有既错又 AC 的本事呢！... ]]> http://imlazy.ycool.com/post.2234422.html Tue, 30 Dec 2008 07:12:06 GMT acm 杭州 icpc 杭电 杭州电子科技大学 ACM-ICPC 2008 杭州之旅 http://imlazy.ycool.com/post.2209673.html
    这次比赛还有一大收获，就是见到了清华 PROXIMA 队的三位天王，并且有幸与他们邻桌比赛，一睹了他的神速。比赛之后我问他们要了一份代码。他们人很大方，不仅毫不吝啬地给了我们代码，而且还让我们事后也发回给他们一份，因为当时他们没有带优盘。我在后面会一一分析他们的算法。



比赛场馆：杭电体育馆，
CBA 浙江万马队主场

楼教主打代码时的风采

我们队的大牛：TRY


东华 TRY 队，从左至右：
TRY、我、FRANKHUHU

黄金雄在颁奖典礼上讲话

清华 PROXIMA 队的三位天王，
从左至右：周源、楼天成、朱泽园
西湖风景：

    由于单篇字数限制，接下来题目分析我就每题单独一篇文章了。虽然有很多事要忙，但是我一有空就会写点儿，会断断续续补全的，可能会花个大半年的时间吧。

    C. Cryptography Reloaded
    D. Déjà vu
    F. Fire-Control System

    未完待续……... ]]> http://imlazy.ycool.com/post.2209673.html Wed, 03 Dec 2008 07:12:48 GMT acm 杭州 icpc 杭电 杭州电子科技大学 PKU 3706， System Test。楼天成出的题很考验人。 http://imlazy.ycool.com/post.2147565.html PKU 3706 的题意是说：一次编程比赛中有 N 个选手（1 ≤ N ≤ 40），M 道题目（1 ≤ M ≤ 40）。每个选手都有一个起平分，在 -2,000 ~ 2,000 之间；对于每道题，各个选手做出它所得到的分数各不相同，在 0 ~ 1,000 之间；如果没做出，都是得 0 分；总分就是起平分加上做出的题目的分数。总分越高的排名越靠前；每个选手都有一个编号，如果有选手总分相同，则编号越小的排名越靠前。最终，排在前 C1 名的选手进入决赛；从第 C1 + 1 名开始，接下来 C2 人进入复活赛；最后 C3 人淘汰（C3 = N - C1 - C2）。问可能有几种不同的比赛结果（分别是哪些人进入决赛，哪些人淘汰）。只要三个集合的人员都相同，即使排名不同，也算是相同的结果。比如有三个人进决赛，则前三名为“甲、乙、丙”与“丙、乙、甲”是同一个结果。

    乍一看是挺难的，需要下面这个重要的结论作为突破口。如果一个人进入决赛了，则即使进把它的排名提前，把前面的人挤下来，决赛的名单也不会改变。同样，对于淘汰的人，即使排名下降，使其它淘汰的人排名上升，总的淘汰名单也不会改变。我们又知道，如果让一个人做出全部题目，则他的排名一定会提前或者不变；如果做出 0 题，则排名一定会下降或者不变。所以说，在一种比赛结果中，让任意进入决赛的选手做出 M 题，或者任意淘汰的选手做出 0 题，结果都是不会改变的。再转化一下，最终的结论就是：

    在每一类等价的比赛结果中，一定有一个是所有进入决赛的人都得满分，而所有淘汰的人都得起平分。

    因此，基本的大方向就是，枚举决赛的最后一名选手 a，和淘汰的第一名选手 b，在此基础上，选 C1 - 1 个人放进决赛， C3 - 1 个人淘汰，其余的人进入复活赛，统计有多少种选法。

    对于一组 a 和 b，不是所有人都可以放进决赛、复活赛或淘汰的。比如一个选手的即使得满分也不如 a 的满分高（前面说了，进决赛的人都是满分），他就不可能进决赛；如果一个选手的起平分比 b 的起平分低，但是它每题的分数都很高，只要做出一题，就立刻超过 a 的满分，则他就不可能进复活赛。诸如此类的判断还需要一些小小的算法。

    40 道题目的对错有 240 ≈ 1012 种可能，但是一名选手的得分没有这么多种可能，因为每道题最多 1,000 分，所以总分一定在 -2,000 ~ 42,000 之间。因此，用一个简单的动态归划就可以算出一个选手的所有可能得分。为了方便比较，可以把选手编号融入到分数中去，即总分 = 原总分 × 100 + (100 - 编号)，这样就可以把总分和选手编号一起比较了，编号较小的，新分数末两位就会较大。

    判断能不能进入决赛或淘汰，只要看满分和起平分就好了。判断能不能进入复活赛，则需要用二分搜索，看一名选手可能得的分当中，存不存在比 a 的满分低，并且比 b 的起平分高的。

    下面要开始计数了，对于每一组 a 和 b，把其余选手分成下面几类：（为了说活方便，把进入决赛的选手称为集合 A，淘汰的称为集合 B，进入复活赛的称为集合 C）

    S1: 可以放进 A 的（满分比 a 的满分高）， S2: 可以放进 B 的（起平分比 b 的起平分低）， S3: 可以放进 C 的（存在一个可能的分数在 a 的满分与 b 的起平分之间）。
    S4: 只能放进 A 的（满足 S1，不满足 S2 和 S3）， S5: 只能放进 B 的（满足 S2，不满足 S1 和 S3）， S6: 只能放进 C 的（满足 S3，不满足 S1 和 S2）。
    S7: 只能放进 A 或 B 的（满足 S1 和 S2，不满足 S3）。
    S8: 只能放进 A 或 C 的（满足 S1 和 S3，不满足 S2）， S9: 只能放进 B 或 C 的（满足 S2 和 S3，不满足 S1）
    S10: 放进 A、 B 或 C 都有可能的（S1、 S2 和 S3 都满足）。

    首先，如果 S1、 S2 和 S3 的人数没有分别达到 C1 - 1、 C3 - 1 和 C2 ，则这组 a 和 b 是不可能的，直接就跳出了。

    接下来，S4 ~ S10 是两两不重叠的。对于 S4、 S5 和 S6，它们是铁定放进 A、 B 和 C 的，放进去之后，把 A、 B 和 C 剩下的空位数记作 DA、 DB 和 DC。

    然后要从 S7 中分配 i 个人放进 A，其余的放进 B。枚举一下 i。

    接着要从 S10 中分配 j 个人放进 C，剩下的人又要分配 k 个人放进 A，其余的放进 B。枚举一下 j 和 k。

    最后，就是要从 S8 中分配 x = DA - i - k 个人放进 A，其余的放进 C；从 S9 中分配 y = DB - (|S7| - i) - (|S10| - j - k) 个人放进 B，其余的放进 C。因此，对于每组 i、 j 和 k，都有 C_{|S_7|}^i × C_{|S_{10}|}^j × C_{|S_{10}|-j}^k × C_{|S_8|}^x × C_{|S_9|}^y 种选法。

    当然，枚举 i、 j 和 k 的时候不要忘了上限： i + j ≤ DA； (|S7| - i) + (|S10| - j - k) ≤ DB；x ≤ |S8|； y ≤ |S9|。

    好了，这就是楼天成的杰作。说穿了每一步都不难，但是关键是要想得到那个突破口，并且把问题分析清楚。这种题目非常能区分出水平，真是好题。... ]]> http://imlazy.ycool.com/post.2147565.html Sat, 01 Nov 2008 13:11:48 GMT acm poj 楼天成 你看过韩国电影《黑帮高中》吗 http://imlazy.ycool.com/post.2144717.html

... ]]> http://imlazy.ycool.com/post.2144717.html Mon, 27 Oct 2008 11:10:09 GMT 电影 韩国 黑帮高中