You scored as Mathematics. You should be a Math major! Like Pythagoras, you are analytical, rational, and when are always ready to tackle the problem head-on! Mathematics 83% Theater 50% Philosophy 50% Engineering 50% Anthropology 33% Chemistry 25% English 17% Linguistics 17% Sociology 17% Dance 17% Psychology 8% Art 8% Journalism 0% Biology 0%

What is your Perfect Major? (PLEASE RATE ME!!<3)
created with QuizFarm.com

9点45 进场。来到64号机前，放好3本牛津高阶，一片紧张，电脑桌面上就只有pc^2的登陆界面。

10点 比赛开始， 看了一下题， 看到在北大的上面做过的"TO THE MAX" ， 万分惊喜， 快速找出 《算法设计与分析》， 同时分配任务给我的队友, chgsh看A题， xp 看B题。心情很紧张，快速的敲这最大子矩阵和的函数， 当时想，这次第一次做出题目的肯定是我们了。。。敲好，提交， NO-wrong answer。心一下子塌下来， 这时候别对队很多都做出的A题(深红色气球)，和G题(粉红色气球)， 这时， chgsh的A题手写出来的， 我就过一旁看C题， 因为我觉得TO THE MAX应该是敲函数的时候出现了一点差错， 要找比较难， 还是先把简单题快点做出来， TO THE MAX晚点再改也行，反正我知道那题不会有太多人能做出来的。。

10点30 chgsh的代码敲完， 调试没问题， 交， NO-wrong answer， 晕， 再改程序， 再交， NO-wrong answer！那时候我们的心情都凝结了， 没想到第一题都做不出， 看到很多红色气球都升起来的， 而我们队还一个气球都没有， 再检查代码， 原来漏掉了结束的标志， 改好， 交! "YES!", 我们不禁叫了出来， 我们互相握手，以示鼓励，毕竟这是0的突破， 意义很大啊！

10点50 xp把写好的B题敲到电脑里面， 交， NO-wrong answer， xp检查代码， 这时我们心情也镇定了， 没有被这NO影响， 我续看C题， 想出来了， xp还在改， 我就继续看G题(这题当时已经有很多人做出来了,所以我想也不难), 想不到就是汉诺塔, 顿时信心十足。这时，晓萍再交程序 NO， 晕死。这时xp叫我一起检查程序，同时把算法告诉我， 我看了程序， 感觉程序一点都没错， 郁闷死。随手把pc^2点出来, 最郁闷的事情发生了， xp交题的时候选错题， 再交, YES! 第二道搞定!

11点20 我决定先把E题(TO THE MAX)检查一遍, 果然, 变量n敲成k了, 改好提交, YES! 我差点跳了起来, 我自己终于做出一题了, 而且那题那个时候还没几个队做出来。chgsh和xp都很高兴， 我们再次握手以示鼓励！

11点50 我继续敲G题(汉诺塔)， 抄了书上的递归程序， 测试， 超时， chgsh说把答案打表吧， 当时我灵机一动， 答案会不会有规律的呢， 决定做个循环把答案打印出来， Bingo, 果然, a[i+1] = 2*a[i] + 1。迅速把程序敲上，提交， YES!

12点 我继续敲C题, 感觉这题比较简单,这时chgsh已经把D题(两页纸的E文)看懂了, 他就和xp商量D题, 而我就继续敲, 当时气氛又紧张了起来,  我想， 如果我把这题拿下了， 那我们对就完成了5题， 拿个小奖应该没问题了。 可能就是这样过于心急， 第一次提交没过， 检查时漏掉了一种情况， 改好交， YES! 看着我们面前那五个颜色的气球。这时已经是12点15分了， 看着面前的面包， 虽然肚子饿， 但是在这种气氛下， 怎么吃得下啊？

12点20分  结合chgsh和我对F题的理解， 觉得F题也不难， 不过F题要考虑的情况很多， 当时头脑发晕， 心情也急， 老是想快点把第6题也做出来(因为这时旁边的队也做了5题)， 于是没有对情况仔细分析， 就去敲代码。。。

13点  代码敲好了， SAMPLE通过， 交吧， NO-wrong answer, 早有预感， 这时xp在手写D题，我想了下我的程序， n个if, n个case, 好混乱， 乱改了一下， 交，在NO-wrong answer， 没法了， 我坐在那里，头好晕。。这时， xp说他的代码写好了，让他试试，OK， 正好我也去冷静下， 仔细想想， F题的情况。

14点 xp敲代码， 而我还在那里发呆， 偶尔看看xp的代码， n个for语句(那题我题意都没理解), 也看不懂他的算法, 头脑就还在发热, 郁闷! 这是chgsh跑过来和我说F题的解法, 给了他想的几个测试数据我, 那几个测试数据就像是救命的灵药, 我开始重新整理思路, 想好F题要改的地方, 这时xp的程序SAMPLE都还没通过, 于是就让我先改F题, 大家都觉得, 做出F题的机会比较大。于是我把我的程序又改了一遍， 再交还是NO-wrong answer。。。。。这时已经离比赛结束只剩下20分钟了。

14点40分  我们的心情都异常的紧张， 因为这时候已经有不少的队伍已经做出了5题(我们旁边那队早就做出了6题了)， 而且我们罚时比较多， 所以情况对我们很不利， 我们必须做出第6题才能有较大的机会拿奖。可是， 对F题， 我已经没有办法了， xp的D题他也没把握， 这时候， chgsh又想到了几个使我的程序错的测试数据， 于是赶紧改上， 没问题， 交。这时候只剩下不到15分钟了， 返回结果：YES!  居然YES了, 是YES!那种感觉, 只能用狂喜来形容!我们再次握手, 我们有机会了!

14点45分 我们还没有放弃, xp上去改他的D题, 居然前两组SAMPLE过了, 叫他赶紧交, 交了再改, 只剩下10分钟了, NO-wrong answer! 这是我们三个一起注视这显示器, 到底那里错呢? 按我的经验, 肯定是溢出问题, 于是叫xp把程序里的1e10改成1000000000交上去试试。 本就没想过能过的， 谁知道， 跳出一个YES的对话框， "过了?" , "我们队做了7题了！"， "xp你太厉害了"， 我们兴奋得差点从椅子上跳起来。我想现在最不爽的肯定是我们旁边的那队， 一直领先我们， 居然在最后20分钟出现了奇迹。。。

15点 比赛结束 周杰老师公布:"有2支队做完了8题， 两支队做了7题。。。"

后记：这次比赛， 给我的唯一感觉就是神奇， 真的是太神奇了， 特别是最后20分钟做出两题， 是三个人合作的成果， 这就是ACM的乐趣， 在这， 我要感谢我的队友chgsh和xp, 我要说："AUCS， 好样的!"


我们队(team64)的排名:

问题分析:
假设一个
struct TreeNode
{
    int tData;
    TreeNode *lp, *rp;//左右儿子的指针
};

规定用递归前序遍历以pNode为根二叉树,把节点指针保存在rs数组中,并返回节点个数cnt.

因为要用递归遍历, 所以cnt必须保留递归每层cnt的值.
实现方法有两种:
1:用by value传值,cnt初值为0;

int travel(TreeNode *pNode, TreeNode **rs, int &cnt)
{
    if (pNode == NULL)
    {
        return cnt;
    }
    rs[cnt++] = pNode;
    travel(pNode->lp, rs, cnt);
    travel(pNode->rp, rs, cnt);
    return cnt;
}

2:用静态变量实现
int travel(TreeNode *pNode, TreeNode **rs)
{
    static int cnt = 0;
    if (pNode == NULL)
    {
        return cnt;
    } 
    rs[cnt++] = pNode;
    travel(pNode->lp, rs, cnt);
    travel(pNode->rp, rs, cnt);
    return cnt;
}

对比1和2,显然2的函数要比1的来得友好,因为在1中增加的参数cnt不属于函数接口,只是为了函数的实现而引入的,所以参数cnt的出现,破坏了接口的友好性.但是如果用2的方法,在函数再次使用的时候static int cnt的值仍保持上次函数被调用时的值,而没有初始化为0,从而达不到函数再次被调用的目的.那有没有好的解决方法呢?

我们利用函数重载,重载travel函数,并在此函数内调用1的travel函数.

int travel(TreeNode *pNode, TreeNode **rs)
{
    int cnt = 0;
    return travel(TreeNode *pNode, TreeNode **rs, int &cnt);
}

这样的话,就能很好的解决了函数接口的友好性,而又不会出现static变量的副作用了.

以上是小弟的一点愚见.

又到了周末,兴致勃勃地从舍友那拷来<<神话>>,一开场,我马上被那壮阔的场面所吸引.

蒙毅将军,骑着他的黑风,身受着护送丽妃的使命,一段迂回曲折的故事,一个神话开始了...不能摆脱的封建礼节,封建教义,深深相爱的蒙毅和丽妃,始终不能过上幸福的生活...

一个千年的承诺,一个千年的等候,丽妃为了她的爱,她的梦想,始终没有放弃,就算知道了jack不是蒙毅的时候,她也没放弃,她还是相信蒙毅没死,放弃了可以逃生的机会,继续留在那个将毁的天宫里,等待她的爱人,坚守她的承诺...

一个千年的故事,一个永不放弃的梦...

但愿自己也能为了自己的梦,为了自己所爱的人,坚持下去,永不放弃!

解开我 最神秘的等待
星星坠落 风在吹动
终于再将你拥入怀中
两颗心颤抖
相信我 不变的真心
千年等待 有我承诺
无论经过多少的寒冬
我决不放手

现在紧抓住我的手 闭上眼睛
请你回想起过去我们恋爱的日子
我们是因为太爱
所以更使得我们痛苦
我们连“爱你“这句话都无法讲
成：每一夜 被心痛穿越
思念永没有终点
早习惯了孤独像随
我微笑面对
相信我 我选择等待
再多苦痛也不闪躲
只有你的温柔能解救
无边的冷漠

现在紧抓住我的手 闭上眼睛
请你回想起过去我们恋爱的日子
我们是因为太爱
所以更使得我们痛苦
我们连“爱你“这句话都无法讲

让爱成为你我心中
那永远盛开的花
穿越时空绝不低头 永不放弃的梦
我们是因为太爱
所以更使得我们痛苦
我们连“爱你“这句话都无法讲
让爱成为你我心中
那永远盛开的花
我们千万不要忘记 我们的约定
唯有真爱追随你我
穿越无尽时空
我们连“爱你“这句话都无法讲
爱是心中唯一不变美丽的神话

原题：

滑雪
Time Limit:1000MS  Memory Limit:65536K

Description
Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

Input
输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

Output
输出最长区域的长度。

我提交的程序：

#include<iostream>
using namespace std;

const int MAX = 102;

struct pos
{
    int i,j,p;//i->行;j->列；p->来源方向
};

int path(int [MAX][MAX],int [MAX][MAX],int[][MAX],int,int);

int main()
{
    int input[MAX][MAX];
    int result[MAX][MAX];
    int status[MAX][MAX];
    int m,n;
    int i,j;
    int max,ans;
    cin>>m>>n;
    for (i = 0; i<=m+1; i++)
        for (j = 0; j<=n+1; j++)
        {
            input[i][j] = 10001;
            result[i][j] = 0;
            status[i][j] = 0;
        }

    for (i = 1; i<=m; i++)
        for (j = 1; j<=n; j++)
        {
            cin>>input[i][j];
        }

    for (i = 1; i<=m; i++)
        for (j = 1; j<=n; j++)
            path(input,result,status,i,j);
    
    max = 0;
    for (i = 1; i<=m; i++)
        for (j = 1; j<=n; j++)
            if (max<result[i][j])
                max = result[i][j];

    cout<<max<<endl;
    return 0;
}

int path(int input[MAX][MAX],int result[MAX][MAX],int status[MAX][MAX],int i,int j)
{
    pos pack[MAX*MAX];
    int max,g,h;
    int ii;
    int top = 0;
    int p = 0;
    int incr[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};//增量表
    
    //初始化
    if (result[i][j]>0)
    {
        return 0;
    }
    else 
    {
        pack[top].i = i;
        pack[top].j = j;        
        pack[top].p = p;
        status[i][j] = -1;    
    }

    while (top>=0||p<4)
    {
        if (p<4)
        {
            g = pack[top].i+incr[p][0];
            h = pack[top].j+incr[p][1];
            //判断是否合法
            if (input[pack[top].i][pack[top].j]>input[g][h])
            {
               if (result[g][h]>0||status[g][h]==-1)//
                   p++;
               else
               {
                   //进栈
                   top++;
                   pack[top].i = g;
                   pack[top].j = h;
                   pack[top].p = p;
                   status[g][h] = -1;
                   p = 0;
               }
            }//合法
            else
            {
                p++;
            }
        }
        else//p==4时
        {
            max = 0;
            for (ii = 0; ii<4; ii++)//四个方向
            {
                g = pack[top].i+incr[ii][0];
                h = pack[top].j+incr[ii][1]; 
                if (input[pack[top].i][pack[top].j]>input[g][h]&&max<result[g][h])
                    max = result[g][h];
            }
            result[pack[top].i][pack[top].j] = max+1;
            top--;//回溯
            p = pack[top].p+1;    
        }
    }
    return 0;
}

此题用到了回溯，和动态规划，也是经典，推荐acmer做做.欢迎交流:)