• 首先呢，我写了一门类似JavaScript的脚本语言，给它取了个华丽丽的名字叫做VScript；
• 然后呢，这个脚本语言支持函数调用，可以调用C++编写的函数；
• 调用函数的时候呢，不小心掉了一个参数；
• 参数列表呢，是使用std::vector来传递的；
• 于是呢，当C++函数体使用到没有传过来的参数时，就导致了std::vector的自动增长；
• 这个自动增长呢，刚好又遇上了内存重新分配（std::vector每增长两倍重分配一次内存）
• 所以呢，前面的参数就华丽丽地析构掉了～（啊！！！）
• 最后呢，我使用前面的参数就会导致纯虚函数被调用啦～
• 解决的办法呢，很简单：把std::vector换成std::deque就搞定啦～
  

NAME

printf, sprintf, snprintf, printerr- print formatted output

SYNOPSIS

$(NUCLEUS_DIR)/lib/embedded/libebd.s.a
#include <stdio.h>

int printf(const char * format, ... /* args */);
int sprintf(char * s, const char * format, ... /* args */);
int snprintf(char * s, size_t size, const char * format, ... /* args */);
int printerr(const char * format, ... /* args */);

API RESTRICTIONS

The function or functions documented here may not be used safely in all application contexts with all APIs provided in the ChorusOS 5.0 product.

See API(5FEA) for details.

DESCRIPTION

The printf() function sends output to the standard output channel, which is system defined. The printerr() function sends output to the standard error channel, which is system-defined. The sprintf() function sends output, followed by the null character ( \\0 ), in consecutive bytes starting at * s ; it is the user's responsibility to ensure that enough storage is available. Each function returns the number of characters transmitted (not including the \\0 in the case of sprintf() ), or a negative value if an output error was encountered.

The snprintf() function writes at most size-1 of the characters printed to the output string (the size character then gets the terminating zero). If the return value is greater than or equal to the size argument, the string was too short and some of the printed characters have been discarded.

Each of these functions converts, formats, and prints its arg s under control of the format .

The format has the general form:

%[flags] [width] [.precision] [{h | l | ll | q | L }]conversion_code

This format is a character string that contains two types of objects: plain characters, which are simply copied to the output channel, and conversion specifications, each of which results in obtaining zero or more arg s. The results are undefined if there are insufficient arg s for the format. If the format is exhausted while arg s remain, the excess arg s are simply ignored.

Flags

The flag characters and their meanings are:

-

The result of the conversion will be left-justified within the field.

+

The result of a signed conversion will always begin with a sign ( + or - ).

blank

If the first character of a signed conversion is not a sign, a blank will be prefixed to the result. This implies that if the blank and + flags both appear, the blank flag will be ignored.

#

This flag specifies that the value is to be converted to an ``alternate form.'' For c , d , s , and u conversions, the flag has no effect. For o conversion, it increases the precision to force the first digit of the result to be a zero. For x or X conversion, a non-zero result will have 0x or 0X prefixed to it. For e , E , f , g , and G conversions, the result will always contain a decimal point, even if no digits follow the point (normally, a decimal point appears in the result of these conversions only if a digit follows it). For g and G conversions, trailing zeroes will not be removed from the result (which they normally are).

Width

The width field is an optional decimal digit string specifying a minimum field width. If the converted value has fewer characters than the field width, it will be padded on the left (or right, if the left-adjustment flag `-', described above, has been set) to the field width. If the field width for an s conversion is preceded by a 0 , the string is right adjusted with zero-padding on the left.

The width field may be indicated by an asterisk ( * ) instead of a digit string. In this case, an integer arg supplies the field width or precision. The arg that is actually converted is not fetched until the conversion letter is seen, so the arg s specifying field width or precision must appear before the arg (if any) to be converted.

Precision

The precision field is an optional field that gives the minimum number of digits to appear for the d , o , u , x , or X conversions, the number of digits to appear after the decimal point for the e and f conversions, the maximum number of significant digits for the g conversion, or the maximum number of characters to be printed from a string in an s conversion. The precision takes the form of a dot ( . ) followed by a decimal digit string. A null digit string is treated as zero.

As for the width field, the precision field may be indicated by an asterisk (*). The meaning is the same as in the width field above.

Argument Size

An optional h , l (ell), q , or ll (ell ell) specifies the expected size of the actual argument for the d , i , o , u , x or X conversion codes. Ignored if specified before any other conversion code.

Their meanings are:

h

The argument is a short integer.

l

The argument is a long integer.

q

The argument is a quad integer.

ll

The argument is a long long integer.

An optional l (ell), or L specifies the expected size of the actual argument for the e , f , or g conversion codes.

They are ignored if specified before any other conversion code.

Their meanings are:

l

The argument is a double.

L

The argument is a long double.

Conversion Codes

The conversion characters and their meanings are:

d , i , o , u , x , X

The integer arg is converted to signed decimal ( d or i ), unsigned octal ( o ), decimal ( u ), or hexadecimal notation ( x and X ), respectively. The letters abcdef are used for x conversion and the letters ABCDEF for X conversion. The precision specifies the minimum number of digits to appear; if the value being converted can be represented in fewer digits, it will be expanded with leading zeroes. (For compatibility with older versions, padding with leading zeroes may alternatively be specified by prepending a zero to the field width. This does not imply an octal value for the field width.) The default precision is 1. The result of converting a zero value with a precision of zero is a null string.

D,O,U

These notations are semantically equivalent to, respectively, ld , lo , lu .

n

The arg should be a pointer to an integer into which is written the number of bytes written to the standard output I/O stream so far by this call. No argument is converted.

p

The arg should be a pointer to void. The value of the pointer is converted to a set of sequences of printable characters.

f

The float or double arg is converted to decimal notation in the style ``[ - ]ddd . ddd,'' where the number of digits after the decimal point is equal to the precision specification. If the precision is not specified, six digits are output; if the precision is explicitly 0, no decimal point appears.

e , E

The float or double arg is converted in the style ``[ - ]d . ddd e+- dd,'' where there is one digit before the decimal point and the number of digits after it is equal to the precision. If the precision is not specified, six digits are produced; if the precision is explicitly 0, no decimal point appears. The E format code will produce a number with E instead of e introducing the exponent. The exponent always contains at least two digits.

g , G

The float or double arg is printed in style f or e (or in style E in the case of a G format code), with the precision specifying the number of significant digits. The style used depends on the value converted: style e will be used only if the exponent resulting from the conversion is less than -4 or greater than the precision. Trailing zeroes are removed from the result; a decimal point appears only if it is followed by a digit.

c

The character arg is printed.

s

The arg is taken to be a string (character pointer) and characters from the string are printed until a null character ( \\0 ) is encountered, or until the number of characters indicated by the precision specification is reached. If the precision is not specified, it is assumed to be infinite and all characters up to the first null character are printed. A NULL value for arg will yield undefined results.

%

Print a % ; no argument is converted.

A non-existent or small field width will never cause truncation of a field; if the result of a conversion is wider than the field width, the field is simply expanded to contain the conversion result. Characters generated by printf() are printed in the same way as if putchar (3STDC) had been called.

Each conversion specification is introduced by the character % . After the % , the following appear in sequence:

• Zero or more flags , which modify the meaning of the conversion specification.

• An optional decimal digit string specifying a minimum field width . If the converted value has fewer characters than the field width, it will be padded on the left (or right, if the left-adjustment flag ` &ndash ;', described below, has been set) to the field width. If the field width for an s conversion is preceded by a 0, the string is right-adjusted with zero-padding on the left.

• An optional l (ell) specifying that a following d , o , u , x , or X conversion character applies to a long integer arg . An l before any other conversion character is ignored.

• A character that indicates the type of conversion to be applied.

EXAMPLES

To print a date and time in the form ``Sunday, July 3, 10:02,'' where weekday and month are pointers to null-terminated strings:

printf("%s, %s %d, %d:%.2d", weekday, month, day, hour, min);

ATTRIBUTES

See attributes(5) for descriptions of the following attributes:

ATTRIBUTE TYPE	ATTRIBUTE VALUE
Interface Stability	Evolving

NAME

scanf, sscanf- convert formatted input

SYNOPSIS

$(NUCLEUS_DIR)/lib/embedded/libebd.s.a
#include <stdio.h>

int scanf(const char * format, ... );
int sscanf(const char * s, const char * format, ... );

API RESTRICTIONS

The function or functions documented here may not be used safely in all application contexts with all APIs provided in the ChorusOS 5.0 product.

See API(5FEA) for details.

DESCRIPTION

The scanf() function reads from the standard input channel, which is operating system dependent. The sscanf() function reads from the character string s . Each function reads characters, interprets them according to a format, and stores the results in its arguments. The functions require, as arguments, a control string format described below, and a set of pointer arguments indicating where the converted input should be stored.

The control string usually contains conversion specifications, which are used to direct interpretation of input sequences. The control string may contain:

1. White-space characters (blanks, tabs, new-lines, or form-feeds) which, except in two cases described below, cause input to be read up to the next non-white-space character.

2. An ordinary character (not % ), which must match the next character of the input channel.

3. Conversion specifications, consisting of the character % , an optional assignment suppression character * , an optional numerical maximum field width, an optional l (ell) or h indicating the size of the receiving variable, and a conversion code.

The format of the conversion specification has the general form:

%[*] [width] [{h | l | ll | q | L}]conversion_code

A conversion specification directs the conversion of the next input field; the result is placed in the variable pointed to by the corresponding argument, unless assignment suppression was indicated using * . The suppression of assignment allows you to define an input field to be ignored. An input field is defined as a string of non-space characters; it extends to the next inappropriate character or until the field width, if specified, is exhausted. For all descriptors except ``['' and ``c'', white space leading an input field is ignored.

Argument Size

An optional h , l (ell), q , and ll (ell ell) specifies the expected size of the actual argument for the d , i , o , u , or x conversion codes. They are ignored if specified before any other conversion code.

Their meanings are:

h

The argument is a pointer to a short integer.

l

The argument is a pointer to a long integer.

q

The argument is a pointer to a quad integer.

ll

The argument is a pointer to a long long integer.

An optional l (ell), or L specifies the expected size of the actual argument for the e , f , or g conversion codes.

They are ignored if specified before any other conversion code.

Their meanings are:

l

The argument is a pointer to a double.

L

The argument is a pointer to a long double.

Conversion Codes

The conversion code indicates the interpretation of the input field; the corresponding pointer argument must be of a restricted type. For a suppressed field, no pointer argument is given. The following conversion codes are legal:

%

A single % is expected in the input at this point; no assignment is performed.

d

A decimal integer is expected; the corresponding argument should be an integer pointer.

u

An unsigned decimal integer is expected; the corresponding argument should be an unsigned integer pointer.

o

An octal integer is expected; the corresponding argument should be an integer pointer.

x

A hexadecimal integer is expected; the corresponding argument should be an integer pointer.

p

Same as the x conversion code, except that the corresponding argument must be a pointer to a pointer to be voided.

i

An integer is expected; the corresponding argument should be an integer pointer. It will store the value of the next input item interpreted according to C conventions: a leading "0" implies octal; a leading "0x" implies hexadecimal; otherwise, decimal.

n

Stores into an integer (whose address is specified in the argument) the total number of characters (including white space) that have been scanned since the function call. No input is consumed.

e , f , g

A floating point number is expected; the next field is converted accordingly and stored through the corresponding argument, which should be a pointer to a float . The input format for floating point numbers is an optionally signed string of digits, possibly containing a decimal point, followed by an optional exponent field consisting of an E or an e , followed by an optional +, -, or space, followed by an integer.

s

A character string is expected; the corresponding argument should be a character pointer pointing to an array of characters large enough to accept the string and a terminating \\0 , which will be added automatically. The input field is terminated by a white-space character.

c

A character is expected; the corresponding argument should be a character pointer. The usual skipping over white space is suppressed in this case; to read the next non-space character, use %1s . If a field width is given, the corresponding argument should refer to a character array; the number of characters indicated is read.

D,O,X,E,F

Are semantically equivalent to, respectively, ld , lo , lx , le , lf .

[

Indicates string data and the usual skipping over leading white space is suppressed. The left bracket is followed by a set of characters, called the scanset , and a right bracket; the input field is the maximaum sequence of input characters consisting entirely of characters in the scanset. The circumflex ( ^ ), when it appears as the first character in the scanset, serves as a complement operator and redefines the scanset as the set of all characters not contained in the remainder of the scanset string. There are certain conventions used in the construction of the scanset. A range of characters may be represented by the construct first-last , thus [0123456789] may be expressed [0-9]. Using this convention, first must be lexically less than or equal to last , otherwise the dash will stand for itself. The dash will also stand for itself whenever it is the first or the last character in the scanset. To include the right square bracket as an element of the scanset, it must appear as the first character (possibly preceded by a circumflex) of the scanset, and in this case it will not be syntactically interpreted as the closing bracket. The corresponding argument must point to a character array large enough to hold the data field and the terminating \\0 , which will be added automatically. At least one character must match for this conversion to be considered successful.

The scanf() conversion terminates at EOF, at the end of the control string, or when an input character conflicts with the control string. In the latter case, the offending character is left unread in the input channel.

Reaching the end of the character string s for sscanf() is equivalent to encountering EOF for scanf() .

The scanf() function returns the number of successfully matched and assigned input items; this number can be zero in the event of an early conflict between an input character and the control string. If the input ends before the first conflict or conversion, EOF is returned.

EXAMPLES

The call:

int i, n; float x; char name[50]; n = scanf("%d%f%s", &i, &x, name);

with the input line:

25 54.32E-1 thompson

will assign to n the value 3 , to i the value 25 , to x the value 5.432 , and name will contain thompson\\0 .

Or:

int i; float x; char name[50]; (void) scanf("%2d%f%*d %[0-9]", &i, &x, name);

with input:

56789 0123 56a72

will assign 56 to i , 789.0 to x , skip 0123 , and place the string 56\\0 in name . The next call to getchar (3STDC) will return a .

NOTE

Trailing white space (including a new-line) is left unread unless matched in the control string.

DIAGNOSTICS

These functions return EOF on end of input and a short count for missing or illegal data items.

ATTRIBUTES

See attributes(5) for descriptions of the following attributes:

ATTRIBUTE TYPE	ATTRIBUTE VALUE
Interface Stability	Evolving

经历
　　上回说到我们Alioth在长春很郁闷了一下。于是这次谁也不敢大意，临出发前大家都狠做了一些题，也狠积了一些ＲＰ。当时我有个预感，我们队应该不会卡题（调不过）。
　　这次比赛的策略与在长春时略有不同，大致来说，由我来负责敲水题与中等难度的题或模拟题，德健主攻比较繁难的题，德健的推导能力比较强，数论题与比较难的ＤＰ就靠他了。
　　比赛开始时，德健看ＡＢＣ，枫耀看ＤＥＦ，我看ＧＨＩＪ。
　　Ｇ题一看便知是一道很繁琐的计算几何题，我们都不太熟，于是先放下。然后ＨＩＪ中Ｉ题很短，便先看Ｉ题，看完之后觉得很难（这个判断之后证明是正确的），想了一下觉得没头绪便也放下了。此时刷board发现Ｊ题有人过，便马上看Ｊ，果然很水，立敲之，过。然后枫耀觉得Ｄ题可以用线段树做，便把题意告诉了我，我想了一下觉得用STL set只要重定义一下排序函数就可以很简单地过掉，而用线段树或平衡树反而会很繁。此时德健与枫耀讨论一下后发现Ａ题可以做，但比较繁，于是我决定先让我过Ｄ题，不出预料，Ｄ题很快也被过掉了。
　　这时德健发现Ａ题有个地方没有处理好，同时发现Ｈ题有很多队过，便看Ｈ题，发现是水题，敲之，ＷＡ，于是打印，发现有小bug，改之，也过了。这时我们过了三题，排名较前。
　　此时德健继续敲Ａ，枫耀把Ｂ题的题意告诉了我。十分可惜的是，我鬼使神差地记错了题目的规模，竟以为只有NlogN以下的复杂度才能过，苦思了一段时间，没任何有意义的结果，于是继续规划Ｇ题，此时德健交了一次Ａ题，ＷＡ，发现题目输出上限是１０亿，刚好爆int，狂晕后改long long交，过，暂时排第一，而Ｃ题是一道类似Apple Tree的树形ＤＰ，很有信心能过，形势一片大好，众皆乐。
　　Ｃ题代码量也不小，于是给德健敲，期间枫耀在想Ｆ题，很神奇地想到一种3⁹*3⁹*9*50的ＤＰ方法，可惜我当时没有给予足够的关注，后来我发现只要稍加一些改进就可以把3⁹变成2⁹，但那已经是比赛结束以后的事了。
　　德健敲Ｃ题时很小心，再加上平时大量做题换来的丰富经验，魔术般地１AC了这道很繁的ＤＰ题，这时离比赛结束还有大约一个半小时。
　　这时我们比较了一下剩下的题目，Ｂ题没想法，Ｆ题复杂度太高，Ｇ题敲起来太烦。想了想还是攻Ｇ题比较好。规划讨论了二十分钟左右时我们发现Ｂ题很多队过，便重新看了Ｂ题，发现了一种Ｎ²的算法，便决定改为全力攻Ｂ题。德健负责敲，我在旁边看，枫耀验证算法。很快地，我们就把程序敲完，交，ＷＡ了。这个ＷＡ来的很诡异，集训时当我们一起攻题时很少遇到这种情况。于是我让德健去看程序，我和枫耀出数据检验，但大家都没能发现问题。一直郁闷到比赛结束。回到酒店后我与ＡＣ一讨论，才发现原来我们把题意理解错了，有一句模棱两可的话把德健和枫耀都骗过了。
　　最终，我们队队排名第４，学校排名第３，虽然还有不少遗憾，但终于能拿到一块金牌，而且还能出线，已经可以算是完美的结局了。

教训
　　我们队的数论，组合数学，博弈方面的能力还是太弱，热身赛时一道ＳＧ定理的水题就把我们ＢＳ掉了。这次比赛能够取得较好的成绩，其实不过是因为没有出到这方面的难题罢了。
　　题目过不了时一定要找人重新审查题目描述，最好能找没有看过题的人来看。假如当时我能重新看一下Ｂ题，很可能我们就能把Ｂ过掉了。
　　
感言
　　这次比赛，是我两年的ACM/ICPC生涯的最后一战，非常感谢我的队友德健与枫耀，是他们的努力使我能够以最好的成绩退役。两年以前，我还没有意识到算法对我会有多重要，那时候，我只是觉得学算法很好玩，做ＯＪ题很有趣而已。而两年之后，当我要到处面试、找工作的时候，才发现原来算法是这么重要，它使我在参加各大公司的面试时都能一路绿灯。因此我非常感激郭老师，给了一个很好的平台去学习算法，去检验学习的成果，给了我很多证明自己能力的机会。还要特别感谢虫子，他给了我最多的帮助，是真正的“有问必答”，没有这个Final级大牛的帮助，我是不可能在短短两年内学到这么多东西的。还有老战友狐狸和飞飞，我永远不会忘记那段一边吃ＢＢＱ一边讨论各种算法难题的日子。感谢所有帮助过我的牛人们。最后还要勉励一下各位师弟师妹，多花点时间和精力研究一下算法吧，保证你不会后悔的～

• 这次比赛筹办得非常好，特别是赛后的晚会非常精彩，表演啦啦操的同学们都是“去过Final的”。
• 吃早餐时千万不要坐错别人的位置，否则会大损ＲＰ的（幸亏我们的德健同学是被坐错那个，于是ＲＰ大升，呵呵）。
• 我一共参加了三场ＡＣＭ亚洲赛，刚好得到一金一银一铜，真可谓“完满”了。呵呵～

行程

• 11月1日 下午~11月3日早上　在火车上度过比较无聊的36 小时
• 11月4日 　试机
• 11 月 5 日 　比赛
• 11 月 6 日 　在长春游玩，但长春实在没什么好玩
• 11 月 6 日 晚 ~11月8日上午　在火车上度过比较无聊的36 小时

比赛

　　比赛一开始，我开屏幕调配置。发现试机时的配置全部被保留。大喜，遂去看题。我看 ABC ，基宏看 DEF ，德健看 GHI 。按照之前的作战布署，此时我们首要的目标是找出最水的题并予以消灭。我很快地看完 A ，发现是一条计算几何题，应该不是水题，便先放在一旁，转而看 B 。 B 题大意是给你一个数 n ，要你找出 k 个数 a₁~a_k ，使得所有 1~n 之间的自然数都可以用 a_i, a_j-a_i, a_j+a_k-a_i 三种方式表示出来，并使得 k 最小。乍看之后像是一条数论构造题，便交给基宏想。此时德健正在看 F 和 H ，前者是一条图论题，后者是一条数据结构题，都不是传说中的最水的题，而且属于德健擅长的类型，我便留给他继续想，继续扫其它题，也帮助基宏一齐想 B ，此时基宏先后找到一些构造的方案，但没能证明它们，而 judge 的返回也说明它们并不正确。

　　比赛一小时后，开始有零星的队过 A ，大多数队还是 0 题。于是拉德健一起讨论 A 。 A 题题意是给出 20 个平面上的点，要求你选取其中一些点，连成一个多边形，使得式子周长平方除以面积取得最小值。马上证得最优的多边形是简单多边形，并且是一个凸包，考虑到点数较少，便想枚举所有凸包，但直接枚举复杂度太高，又无法找到一种遍历凸包的算法。稍后，我们发现一种遍历所有简单多边形的算法，复杂度为 n 2ⁿ ， 10s 的限时绝对能过，便交给德健敲，在经历了几次小 bug 带来的 TLE 后，我们终于迎来了第一个 yes 。此时暂时排名十几，很多队过了的 E 题我们还未过，形势看来不错。二队和六队还未过题。为他们祈祷了一下，继续做题。

　　E 题又是一道数论题：给出一个复数，判断是否高斯素数。我便和基宏一起想 E ，并写了一个暴力枚举的程序来把小范围的高斯素数打印出来找规律，然后我去想 D ， D 题目较长，但其实是一个很容易想到的一个 DP 。看完题后不久便想到了算法。但觉得有点繁琐，而且复杂度好像有些高而且不容易算出准确的复杂度，便等到德健过 A 后再交给他敲。另外 E 题我们在《初等数论》上也找到一些结论，可惜我们看不懂证明。后来我写了一个 n² 的水的方法，却水了几次都没有水过。

　　这时评委看到 A 题过的人太少，便做了件最令人匪夷所思的事：对 A 题连续多次 rejudge ，最终把时限改为用最强大的布鲁特福斯算法都可以过的题，一下子哗啦啦地过倒一大片，我们一个小时的努力换来的的优势顿时化为乌有。

　　不幸中的万幸是，当我用了各种预处理和水的方法都过不了 E 而打算放弃之时，基宏很神奇地修改了其中的一个参数，改大了枚举量，就把 E 过掉了。

　　这时德健已经敲了一部分 D 题，但似乎遇到一些困难，却又无法说出来。之后他便去想 F ，然后决定先水一下 F 。这是一个有关最短路的问题，很不幸地我们选择了使用 Floyd 来求最短路，结果无论怎样改都没法水掉道这题（后来六队用对所有点求 Dijikstra 的方式过掉了这题，实在太神奇，膜拜orz~）。在比赛结束前 40 分钟左右，我们终于放弃 F 来继续做 D ，由于此前我已算出准确的复杂度是 O(500*270*12*case 数 ) 左右，所以那时我觉得把 D 过掉的希望还是很大的。这时德健终于说出了他遇到的困难，原来他把我的算法和他之前的一些想法搞混了，结果我们花了很大力气才取得了一致。最后的时间是在我和德健一齐敲 D 题、调 D 题中度过的，可惜最后都没调过。

教训

1、  不要以为 g++ 一定会对简单的 inline 函数进行展开。这次比赛的 g++ 对我们测试的所有的简单 inline 函数都不展开。

2、  不要以为题目的标准解法不用打表。本次比赛花了我们很多时间的 B 题的标准解法就是花几个小时去暴力打表。

3、  作为队长，我应该更清楚队员的状态，并且更灵活地调整策略。今次比赛德健明显状态不佳，我应该在更早的时候意识到这个问题。

4、  数论和组合数学是我们队的弱项，这次我们的数论题过得很险，相信随后的成都之战会更加艰苦。必须在接下来的休整时间里尽力恶补一下。

5、  我们队的交流还是做得不够。其实那条花了德健很多时间的 H 题，正是我擅长的线段树题目，而事后也证实那道题真的很容易想出来，但我却因为各种原因没有认真去想。

花絮

1、  在去长春的火车上，大家都在努力看书和论文，还讨论一些以前的题目，其间我发现某题可以用 O(n(nlogn)^1/2 ) 的复杂度过。这是我想过的题中“最复杂”的一个复杂度。

2、  去长春的路上大家都没有打太多牌，怕伤 RP 。很不幸地我连胜了几局，赶紧收手去睡觉。回广州的路上终于可以放手打牌了，大败而归。

3、  由于是第一次在深秋时节跑到北方去（假如前几天飞去北京面微软不算的话，但显然长春要比北京冷多了）所以大家都准备了很多御寒衣物。去到后发现其实也没有想像中那么冷，我的围巾和最厚的绵袄都没有用过。

4、  王磊在火车上开玩笑地说他在实验室研究“布鲁特福斯”（ brute force ）算法。我们的德健更号称“系数之王”。很不幸地，这次我们遇上了更加暴力的评委，方知“强中还有强中手”。

5、  在去长春火车上的第一晚，我接连推掉了百度、网易和腾讯的面试，当时感觉心痛无比。不过很幸运地，最终我还是赶在百度团队飞回北京前获得了面试的机会，并很顺利地拿到了 offer 。 ^_^

6、  比完赛后二队和郭老师随即飞回了广州，剩下六个大男人在长春逛沃尔玛，囧。

7、比赛服装的size除了印的码数不同外几乎没有什么差别，导致我们的基宏同学选了件XXL，而肥东师兄却选了件M。

发现

1、  东北有很多西南菜，尤其是云南过桥米线。

2、  在北方千万不要乱点“清淡”的菜，它可能辣得令你无法下咽。一个较好的做法是叫师傅“绝对不放辣椒”，但这时师傅很可能会跟你说那道菜他不会做了。

3、  坐火车千万不要坐车厢两边，除非你不介意车上那帮烟鬼们日夜不停地轮番轰炸。

4、  一个城市的空气和饮用水质量真的很重要的，为了这两个原因我打死都不会到长春去生活。

5、  长春的轻轨很慢，而且车站很密，一两分钟就停一次站，使我们怀疑步行是否会比坐轻轨更快。

6、  原来在手机 QQ 上是看不到对我可见的密友的，由于大家都习惯隐身，结果我经常觉得 Q 上一片冷清。

鸣谢

• 谢谢郭 老师给了我代表中山大学到长春比赛的难得的机会。
• 谢谢队友德健和基宏给了我这个菜鸟队长许多支持和帮助。和你们一起并肩奋斗是我毕生难忘的一段经历。
• 谢谢嘉慧借给我手机，使我没有错过任何一个重要的面试电话，并且在旅途中可以一直用 QQ跟大家 聊天。我那只肥猪仔现在经常“智能悭电”了。
• 谢谢在这次旅程中帮助过我、关心过我的所有人，谢谢你们。

XmlTextReader myXmlTextReader = new XmlTextReader ("textToValidate.xml");XmlValidatingReader myReader = new XmlValidatingReader(myXmlTextReader);myReader.Schemas.Add(myXmlSchemaCollection);myReader.ValidationEventHandler += new ValidationEventHandler (this.ValidationFailureHandler);// 读取 XML 数据。while (myReader.Read()){}

• 在 Visual Studio .NET 中，从菜单中选择 File（文件），再选择 Open（打开），然后选择 Project（项目）。
• 找 到 MDIWordPad.vjp 项目文件的位置并单击 Open（打开）。Visual Studio .NET 检测到您要打开的文件是 Visual J++ 6.0 项目并打开 Visual J# .NET Upgrade Wizard（Visual J# .NET 升级向导）。
• 阅 读完介绍文字后，单击下一步进入向导的第二页。此页面要求提供您正在升级的项目的类型信息。MDIWordPad 示例是一个 Windows 应用程序，因此默认值是正确的。如果您要升级的项目是一个控制台应用程序或类库，您就应该选择一个选项。确认选定了 Windows 应用程序后，单击下一步进入升级向导的下一页。图 4：Visual J# .NET Upgrade Wizard（Visual J# .NET 升级向导）提示选择项目目标类型

• 对 于使用 Active X 控件或其他 COM 引用的应用程序，您可以在这一页上明确添加对这些组件的引用。添加这些引用可以帮助升级向导找到项目中使用的附加类型。虽然即使您不在这里指定它们，升级 向导也可以找到并将这些引用添加到项目中，但是现在添加它们可以加快升级速度。MDIWordPad 没有使用任何外部组件，因此请单击 Next（下一步）而不需要做任何改动。
• 现在，升级向导开始评估项目并将项目文件和引用升级到 Visual J# .NET。会显示一个状态条和变化的文本，提示向导目前的进度。处理结束之后，升级向导将自动进入最后一页。
• 在 向导的最后一页中，您可以使用一个复选框选择是否查看项目升级报告。单击 Finish（完成）显示升级报告。升级报告列出了有关应用程序及升级进程的信息。如果在项目转换中发现了问题或丢失的引用，它们将在这里列出。该报告中 还包括有关升级向导向新解决方案中添加的文件的信息。
• 在 Solution Explorer（解决方案资源管理器）中双击文件 MDIWordPad.java 以便在 Code Editor（代码编辑器）中将其打开。通过浏览该文件，您会发现源代码看起来与原先完全相同。事实上，将一个项目升级到 Visual J# .NET 并不要求任何形式的源代码修改，所要求修改的只是解决方案、项目和资源文件。源代码文件本身的内容保持不变。
• 按 F5 运行升级后的应用程序。应用程序的表现没有变化，您可以通过编辑一些文本来验证这一点。应用程序的操作与升级前完全相同，只是它现在是运行在 .NET 上。图 5：MDIWordPad 的升级版本，运行在 Visual Studio .NET 上，使用 .NET

• 在 Visual Studio 中的 File（文件）菜单上单击 Open（打开），然后单击 Convert（转换）。这将启动 Conversion（转换）对话框。
• 选定 Java Language Conversion Assistant（Java 语言转换助手）图标后单击 OK（确定），启动 Java Language Conversion Assistant（Java 语言转换助手）。
• 虽然原应用程序是使用 Visual J++ 编写的，但本例中将它视作一个基于目录的转换。在向导的第二页中选择进行基于目录的转换选项，然后单击 Next（下一步）。
• 在 Java Language Conversion Assistant（Java 语言转换助手）的第三页中，选择包含应用程序源代码的目录，然后单击 Next（下一步）。
• 向导的第四页要求您输入一些有关应用程序的信息。键入“Bookstore"作为项目名。其他两个选项使用默认值，然后单击 Next（下一步）。图 7：提供有关您的项目的信息

• 现 在，Java Language Conversion Assistant（Java 语言转换助手）询问将转换后的项目文件写到哪里。选择要使用的目录后单击 Next（下一步），必要时让 Java Language Conversion Assistant（Java 语言转换助手）创建目录。
• 再次单击 Next（下一步）开始转换。转换完成后向导结束。单击 Close（关闭）按钮关闭向导。
• 按 SHIFT+F7 打开窗体设计器。请注意，在设计器中可以看到窗体及其组件。Java Language Conversion Assistant（Java 语言转换助手）将 AWT 组件转换成了 Windows 窗体组件。可以使用 Windows 窗体设计器查看转换后的窗体。图 8：AWT 框架被转换成了 Windows 窗体

• 从 View（视图）菜单中选择 Task List（任务列表）。您将看到转换后的文件中添加了几条升级说明。必须先解决这些问题应用程序才能正常运行。（如果现在生成和运行该应用程序，您将会发现该应用程序能够出现但是没有可用数据。）
• 双 击 Task List（任务列表）中的第一条注释，这将通过 retrieveData() 方法将光标移到第一条错误。此方法负责查询数据库并将有关可用标题的信息返回给应用程序。浏览此方法的代码会发现 JDBC 调用被转换成了 ADO.NET 调用。必须做些必要的修改后此代码才能正确运行。
• 在 retrieveData 中，第一条注释 Upgrade_ToDo 说方法 Class.forName 参数的格式已改变。这条注释下面的代码行用于加载原代码中的 JDBC 驱动程序，但是对于 ADO.NET 不必这样做。请删除这条转换说明及其下面的代码行。
• 下一条转换注释告诉您 ADO.NET 中的连接字符串格式改变。如果您已经知道新的连接字符串格式，就将它输入到变量 URL 的声明中。 您还可以使用 Visual Studio .NET 中的工具编写字符串，而不必记住连接字符串的格式。
• 按 SHIFT+F7 在设计器中打开窗体。从 ToolBox（工具箱）的 Data（数据）选项卡中，将一个 OleDbConnection 对象拖到窗体上。在 Properties（属性）窗口中，单击 ConnectionString 属性的下拉列表并选择 New Connection（新连接）。这将显示 Data Link Properties（数据链接属性）对话框，帮助您指定一个数据库连接。
• 保 存所提供书籍的信息的数据库是一个 Access 数据库。当从一个 ADO.NET 的 Access 数据库中读取数据时，您可以使用 Microsoft Jet 4.0 OLE DB 提供程序。在 Data Link Properties（数据链接属性）对话框中单击 Provider（提供程序）选项卡选择该数据提供程序，然后单击 Next（下一步）。找到该示例数据库的 .mdb 文件，然后单击 OK（确定）。
• DataAdapter 的 ConnectionString 属性现在包含格式正确的示例数据库连接字符串。将此字符串复制并粘贴到 retrieveData 方法的 URL 变量的声明中。在字符串前添加一个 @ 符号，以告诉 C# 应该按字面解释该字符串。修改后，声明或 URL 应该如下所示： String URL = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source =..\..\db.mdb;"; 现在，这个升级问题已经解决，您可以删除这条转换注释。后面的两条升级注释不影响本应用程序，可以忽略或删除它们。
• 按 F5 运行该应用程序。该应用程序将被加载，您可以看到它的工作状态与原应用程序相同。我们以最容易的方式将这个两层的应用程序从 Java 转换成了 C#。虽然该应用程序很小，但是上面介绍的方法适用于所有转换项目。

它能够实现的功能：

1. 与Java.exe功能类似的java虚拟机ikvm.exe
2. 通过ikvmc.exe将class文件或jar包转换成dll或exe文件（取决于类里边是否有main方法和参数设置），这时会作一些转换，包括：
   
   • 类型的映射，比如将java.lang.Object映射到System.Object等
   • 一些语言元素的对应转换，package对应namespace，jar文件对应dll文件
     
3. 通过ikvmstub.exe来根据.net程序集生成对应的java存根类（有声明没有实现的类），使得引用到.net库的java代码能够被编译成.class文件。

1. 将java类转换成dll程序集或exe文件，从而被用C＃编写的类调用，或者独立运行。
   C#貎似不能引用其它dll里的默认namespace里边的内容，所以java文件必须声明包，以便被转换成命名空间。<br>此外，因为 java中默认访问权限的方法会被转换成internal方法，所以在java中必须将这些方法显式地声明为public
   
   

1. 在java中，没有声明访问权限的方法默认是public的，但转换后的方法访问权限是internal的。
2. 0.34.0.2 Release版的问题：当被编译的类中有main()方法时，ikvm会自动将其编译成exe文件，但这个exe文件不可执行。不过该版本将类库编译成dll貌似没有问题，而且ikvm.Runtime.dll等可以放进全局程序集缓存（GAC）。
3. hybrid-0.35.2769版的问题：该版本编译生成exe没有问题，但IKVM.Runtime.dll等自身的dll文件无法放入GAC，比较麻烦。
4. 在java部分使用了java.io.File类时会引发异常（仅测试了hybrid-0.35.2769版），（ ikvmbin-hybrid-0.35.2777.zip 解决了这个问题）
   异常输出
   未处理的异常:  System.TypeInitializationException: “java.lang.ClassLoader”的类
   型初始值设定项引发异常。 ---> System.TypeInitializationException: “IKVM.NativeC
   ode.java.lang.Thread”的类型初始值设定项引发异常。 ---> System.Reflection.Target
   InvocationException: 调用的目标发生了异常。 ---> System.ArgumentNullException:
   值不能为空。
      在 System.Threading.Monitor.Enter(Object obj)
      在 java.lang.ClassLoader.loadLibrary0(Class , File )
      在 java.lang.ClassLoader.loadLibrary(Class , String , Boolean )
      在 java.lang.Runtime.loadLibrary0(Class , String )
      在 java.lang.System.loadLibrary(String libname)
      在 java.lang.System.initializeSystemClass()
      --- 内部异常堆栈跟踪的结尾 ---
      在 System.RuntimeMethodHandle._InvokeMethodFast(Object target, Object[] argum
   ents, SignatureStruct& sig, MethodAttributes methodAttributes, RuntimeTypeHandle
    typeOwner)
      在 System.RuntimeMethodHandle.InvokeMethodFast(Object target, Object[] argume
   nts, Signature sig, MethodAttributes methodAttributes, RuntimeTypeHandle typeOwn
   er)
      在 System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invoke
   Attr, Binder binder, Object[] parameters, CultureInfo culture, Boolean skipVisib
   ilityChecks)
      在 System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invoke
   Attr, Binder binder, Object[] parameters, CultureInfo culture)
      在 System.Reflection.MethodBase.Invoke(Object obj, Object[] parameters)
      在 IKVM.NativeCode.java.lang.Thread..cctor()
      --- 内部异常堆栈跟踪的结尾 ---
      在 IKVM.NativeCode.java.lang.ClassLoader.registerNatives()
      在 java.lang.ClassLoader.registerNatives()
      在 java.lang.ClassLoader..cctor()
      --- 内部异常堆栈跟踪的结尾 ---
      在 java.lang.ClassLoader.getCallerClassLoader()
      在 java.lang.Class.forName(String className)
      在 fileTest.FileTest.mkdir(String str)
      在 FileTestMain.Main(String[] arg)
   

Maven [java]
Java项目管理工具

jarbrowser [java]
包查找给管理工具，能够通过类名或包名反查jar包路径(本地)
如果是在线查找可通过http://www.whatjar.net/

 ·变量查看/赋值器
  功能：该调试器可以查看指定的变量，并重新赋值
  用法：如果只想查看变量本身，点"查看"
  　　　如果想查看变量的属性、方法等，点"查看详细"
  　　　可以用变量的值或常量来赋值
  　　　本调试器尝试将各字段的字符串转换为代表的值，具体顺序见下文“myEval()转换的顺序”。

　　编程方面，该调试器还在_global里注册了以下API以方便调试：
 ·myEval()
  用法1：function myEval(target:String):Object
  说明：本函数是eval()函数的扩展，支持转换到各种内置类型。
  用法2：function myEval(target:String, newVal:String):Object
  说明：本函数是eval()函数的扩展，支持用各种常量、变量为target赋值。

 ·myEval()转换的顺序
 　　1、如果字符串由""括起，则返回""之间的字符串；
 　　2、尝试转换为this、数字、布尔值和undefined；
 　　3、尝试转换为已存在的全局变量；
 　　4、尝试转换为已存在的时间轴变量；
 　　5、尝试转换为新的时间轴变量；
 　　6、返回undefined。

 ·myTrace()
  用法1：function myTrace(msg:String)
  说明：本函数是trace()函数的扩展，msg将被输出到调试器输出和Flash内置输出上
  用法2：function myTrace(msg:String,'+')
  说明：使用这种格式时，之前的调试器输出会被保留。

 ·see()
  用法：function see(targetStr:String):String
  说明：本函数可以查看对象本身、子对象、属性、方法等的类型和值。

一些例子：
 ·在“函数调用”中输入Math.cos，在“函数参数”中输入Math.PI，点“执行”，则有如下输出：
  函数名：Math.cos
  参数名：Math.PI
  参数值：3.14159265358979
  this对象：_level0
  执行结果：-1

 ·在“变量名”中输入_root，点“查看详细”，则有如下输出：
  see _root (movieclip) = _level0
  setStyle (function)
  notifyStyleChangeInChildren (function)
  ……

 ·在“变量名”中输入_root.a，在“赋新值”中输入"hello"，点“赋值”，则有如下输出：
  变量名：_root.a
  变量类型：undefined
  变量值：undefined
  新变量类型：string
  新变量值：hello

 ·在你的程序里，调用see("_global")，则会返回
  see _global (object) = undefined
  __SVMouseWheelManager (object)
  getStyleCounter (number) = NaN
  see (function)
  myTrace (function)
  myEval (function)
  ……
　　希望大家喜欢这款调试器！如果有什么建议可以留言说说，想索要源代码的话也可以Q我或者回贴留下e-mail。

（当然，有时我不得不暂时中止，比如说去上海比赛暂停了一个星期，期末考也有近两星期无暇顾及它等乖）

这样逐渐积累下来，这次发布的Beta已经和上次的有较大的不同，现将其进展情况摘要列出：

外观及交互功能的进展
改变了网站各页的设计，将每页都分为公用的页首和各自私有的正文页面。这种设计类似于普通网站的框架网页，但比之更为自然、随意和易于升级维护。
　　添加了使用方便的导航栏，以便于在各页间进行跳转，其所有数据也是用独立的xml数据文件保存，以坚持数据、功能、显示相互分离的原则。花了很大力气完成了导航栏与各页各组件的通信。
　　重新制作了首页页面。
　　在经典行程页面增加了地区选择组件。并完成了它与线路列表和行程介绍板块之间的通信。
　　重写了各种介绍板块动态显示的代码，使之更加简洁和高效。
　　修敢了旅游线路数据文件的结构，使之能保存多地区的旅游数据，并且加入对图片地址链接的信息，使得在通过文字显示每天的旅游介绍时，还可以动态显示相关的图片，并根据数据文件的记录自动加载和自动切换

。
　　针对上一个Beta版本的行程介绍板块在旅游天数过多时较难切换页面的问题，这个版本特地引入“切换到第一天”、“切换到最后一天”、“切换到指定的任意一天”等的控件，再加上原有的“页面标签”和“切换到前一天”、“切换到后一天”组件，相信现在进行页面跳转将是一种愉快的体验。
　　在机票查询页面上使用两个ComboBox（分别用于选择地区和城市）和一个DataGrid来显示航线消息。之间信息能够相互同步更新。
　　改写了航线数据文件的结构，将原本航线数据与显示控制信息混杂保存的方式改变为数据和显示抑制信息分别用不同的分支保存。并增加了其对显示的控制功能。同时，将所有的属性名改为英文，以保证与IE等浏览器的兼容性，进一步的扩展做准备　　
　　
内部实现的技术进展
　　通过自写函数assert()、assertValid()和see()还有简单调试面板来使跟踪变量、查找错误提高了效率。
　　增加了自写的组件事件设置函数，使为组件设置响应函数变成一项简单的工作。
　　增加了用于追踪组件事件或调用者的信息的debug函数。
　　设计了onFrameManager，使用其onFrame函数可以有效地处理页面跳转时的异步问题，通过延迟一帧触发的方式来保证在调用前相关变量和组件已被正确初始化。
　　在各函数里大量使用自定义的断言以保证程序的健壮性和阻止数据错误传播。同时引入Alert组件，使得用户能很容易地了解到相关的错误。
　　为改变此前的Beta版本中对xml文件进行读取的相关代码冗长、可读性低的缺点，引入XPath类，尝试通过xml路径来查找、引用节点。

已解决的技术难题
　　最重要的一个是解决了MenuBar组件被点击时不发出事件的问题，通过重写其内部的实现函数来解决。
　　还有是在页面跳转时变量失效与函数被调用时相关变量未初始化的问题，主要通过一个Array对函数寄存和延迟一帧触发来完成。
　　解决了在一些情况下会导致死循环的问题。
　　

　　Sicly今晚又有周赛了，兴致勃勃地找了一道题来做，却调了几个钟都找不到一个错误的数据，但总是返回Wrong Answer！只好贴到此处，请教各位大牛。

题目大意
给出平面上n(n<=10⁵)个点的X、Y坐标(xi,yi)(0≤xi,yi≤10⁹)及权值pi，求一条折线，满足：
1）折线只能向X正方向或Y正方向延伸；
2）折线的权值定义为折线上所有点的权值之和。
输出权值最大的折线的权值。

我的做法
先离散化，然后将n个点按第一顺序为X升序，第二顺序为Y升序来排序。
再建一棵线段树，每读一个项Pi =(xi, yi, pi);就在线段树里查询pi点的颜色C(yi)，并加一条线段(yi,+∞)，使得线段上每一点q的颜色C(qi)=max(C(yi)+pi,C(qi))。 最后输出C(+∞)即可。时间复杂度O(NlogN)，空间复杂度O(N)。代码如下：

#include < cstdio >
#include < cstring >
#include < algorithm >
#include < iostream >
using   namespace  std;
const   int  N = 100010 ; // 车站数
int  rx[N],ry[N],p[N],x[N],y[N],xp,yp;
struct  S { // 一个车站
   int  x,y,p;
   bool   operator   < ( const  S &  o) const {
     return  x == o.x ?  y < o.y : x < o.x;
  }
}  t[N];

template < int  N >
class  PntTree {  // 线段树的一种实现
     int  a[ 2 * N];
   public :
     /**/ /*  断言: i∈[0,N-1) (N-1用于表示+∞)  */
     void  add( int  i, int  c) { // 添加点i
      c += C(i);
         for (a[i += N] = c; i > 1 ; i /= 2 )  if ( ~ i & 1 )  if (c > a[i / 2 ]) a[i / 2 ] = c;  else   return ;
    }
     int  C( int  i) { // 返回点i的颜色
         int  c = a[i + N];
         for (i += N; i > 1 ; i /= 2 )  if (i & 1 ) c = max(c,a[i / 2 ]);
         return  c;
    }
} ;
PntTree < 131072 >  tr;
int  main() {
   int  i,j,n,tx,ty;
  scanf( " %d%d%d " , & tx, & ty, & n);
   // 离散化
  xp = yp = 0 ;
   for (i = 0 ; i < n;  ++ i) {
    scanf( " %d%d%d " , & rx[i], & ry[i], & p[i]);
    x[xp ++ ] = rx[i];
    y[yp ++ ] = ry[i];
  }
  sort(x,x + xp);
  sort(y,y + yp);
  xp = unique(x,x + xp) - x;
  yp = unique(y,y + yp) - y;
   for (i = 0 ; i < n;  ++ i) {
    t[i].x = lower_bound(x,x + xp,rx[i]) - x;
    t[i].y = lower_bound(y,y + yp,ry[i]) - y;
    t[i].p = p[i];
  }
   // 排序
  sort(t,t + n);
   // 线段树操作
   for (i = 0 ; i < n;  ++ i) {
     // cout<<t[i].x<<' '<<t[i].y<<' '<<t[i].p<<' '<<tr.C(t[i].y)<<"->";
    tr.add(t[i].y, t[i].p);
     // cout<<tr.C(t[i].y)<<endl;
  }
   // 输出无穷远处的颜色
  printf( " %d\n " ,tr.C(N - 1 ));
   return   0 ;
}

附：题目全文

Task: The Bus

The streets of Byte City form a regular, chessboardlike network - they are either north-south or west-east directed. We shall call them NS- and WE-streets. Furthermore, each street crosses the whole city. Every NS-street intersects every WE- one and vice versa. The NS-streets are numbered from 1 to n, starting from the westernmost. The WE-streets are numbered from 1 to m, beginning with the southernmost. Each intersection of the i-th NS-street with the j-th WE-street is denoted by a pair of numbers (i, j) (for 1 <= i <= n, 1 <= j <= m).

There is a bus line in Byte City, with intersections serving as bus stops. The bus begins its itinerary by the (1, 1) intersection, and finishes by the (n, m) intersection. Moreover, the bus may only travel in the eastern and/or northern direction.

There are passengers awaiting the bus by some of the intersections. The bus driver wants to choose his route in a way that allows him to take as many of them as possible. (We shall make an assumption that the interior of the bus is spacious enough to take all of the awaiting passengers, regardless of the route chosen.)

Task

Write a programme which:

• reads from the standard input a description of the road network and the number of passengers waiting at each intersection,
• finds, how many passangers the bus can take at the most,
• writes the outcome to the standard output.

Input

The first line of the standard input contains three positive integers n, m and k -- denoting the number of NS-streets, the number of WE-streets and the number of intersections by which the passengers await the bus, respectively. (1 <= n <= 10⁹, 1 <= m <= 10⁹, 1 <= k <= 10⁵).

The following k lines describe the deployment of passengers awaiting the bus, a single line per intersection. In the i + 1st line there are three positive integers x_i, y_i and p_i, separated by single spaces, 1 <= x_i <= n, 1 <= y_i <= m, 1 <= p_i <= 10⁶. A triplet of this form signifies that by the intersection (x_i, y_i)p_i passengers await the bus. Each intersection is described in the input data once at the most. The total number of passengers waiting for the bus does not exceed 1 000 000 000.

Output

Your programme should write to the standard output one line containing a single integer - the greatest number of passengers the bus can take.

Example

For the input data:

8 7 11
4 3 4
6 2 4
2 3 2
5 6 1
2 5 2
1 5 5
2 1 1
3 1 1
7 7 1
7 4 2
8 6 2

the correct outcome is:

11

题目来源

　　至此，这个全Flash实现的网站便有了个雏形了。
　　当然，大家一看就知道，还有很多具体细节没有实现，外观风格也不太统一。不过，对于我来说，这个作品最难搞的部分在于代码，当几个文件的代码无错误冲突地放在一起时，我离成功也就不远了^_^
　　基于时间上的原因，我还没有把地图控件整合到这份草稿里去，但
　　欢迎大家给点建议，尤其欢迎是关于该作品功能上的建议（因为我打算稍迟再考虑外观的问题）

P.S.：我装饰首页的那幅世界地形图得到了Leana的赞赏，这使我非常高兴＊＾＿＾＊。但我其实一直在考虑这种装饰是否值得，因为它把本来只有80K的flash一下子膨胀到230K，窃以为不值。我自己的想法是做一个新闻中心，这样的话就会有一种门户网站的感觉了。

我设计的地图控件，具体的图是可以任意选用的，控件本身支持对地图的放大、缩小、拖动、自动卷屏等操作。

    1.1  标准输入输出函数

    1.1.1 格式化输入输出函数
    Turbo C2.0 标准库提供了两个控制台格式化输入、 输出函数printf( ) 和
scanf(), 这两个函数可以在标准输入输出设备上以各种不同的格式读写数据。
printf()函数用来向标准输出设备(屏幕)写数据; scanf() 函数用来从标准输入
设备(键盘)上读数据。下面详细介绍这两个函数的用法。
    一、printf()函数
    printf()函数是格式化输出函数, 一般用于向标准输出设备按规定格式输出
信息。在编写程序时经常会用到此函数。printf()函数的调用格式为:
      printf("<格式化字符串>", <参量表>);
    其中格式化字符串包括两部分内容: 一部分是正常字符,  这些字符将按原
样输出; 另一部分是格式化规定字符, 以"%"开始, 后跟一个或几个规定字符,
用来确定输出内容格式。
    参量表是需要输出的一系列参数, 其个数必须与格式化字符串所说明的输出
参数个数一样多, 各参数之间用","分开, 且顺序一一对应,  否则将会出现意想
不到的错误。
    1. 格式化规定符
    Turbo C2.0提供的格式化规定符如下:
━━━━━━━━━━━━━━━━━━━━━━━━━━
   符号                  作用
──────────────────────────
    %d              十进制有符号整数
    %u              十进制无符号整数
    %f              浮点数
    %s              字符串
    %c              单个字符
    %p              指针的值
    %e              指数形式的浮点数
    %x, %X          无符号以十六进制表示的整数
    %0              无符号以八进制表示的整数
    %g              自动选择合适的表示法
━━━━━━━━━━━━━━━━━━━━━━━━━━
    说明:
    (1). 可以在"%"和字母之间插进数字表示最大场宽。
     例如:  %3d   表示输出3位整型数, 不够3位右对齐。
            %9.2f 表示输出场宽为9的浮点数, 其中小数位为2, 整数位为6,
                  小数点占一位, 不够9位右对齐。
            %8s   表示输出8个字符的字符串, 不够8个字符右对齐。
    如果字符串的长度、或整型数位数超过说明的场宽, 将按其实际长度输出。
但对浮点数, 若整数部分位数超过了说明的整数位宽度, 将按实际整数位输出;
若小数部分位数超过了说明的小数位宽度, 则按说明的宽度以四舍五入输出。
    另外, 若想在输出值前加一些0, 就应在场宽项前加个0。
    例如:   %04d  表示在输出一个小于4位的数值时, 将在前面补0使其总宽度
为4位。
    如果用浮点数表示字符或整型量的输出格式, 小数点后的数字代表最大宽度,
小数点前的数字代表最小宽度。
    例如: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9,  则
第9个字符以后的内容将被删除。
    (2). 可以在"%"和字母之间加小写字母l, 表示输出的是长型数。
    例如:   %ld   表示输出long整数
            %lf   表示输出double浮点数
    (3). 可以控制输出左对齐或右对齐, 即在"%"和字母之间加入一个"-" 号可
说明输出为左对齐, 否则为右对齐。
    例如:   %-7d  表示输出7位整数左对齐
            %-10s 表示输出10个字符左对齐
    2. 一些特殊规定字符
━━━━━━━━━━━━━━━━━━━━━━━━━━
    字符                           作用
──────────────────────────
     \n                   换行
     \f                   清屏并换页
     \r                   回车
     \t                   Tab符
     \xhh                 表示一个ASCII码用16进表示,
                          其中hh是1到2个16进制数
━━━━━━━━━━━━━━━━━━━━━━━━━━
    由本节所学的printf()函数, 并结合上一节学习的数据类型, 编制下面的程
序, 以加深对Turbo C2.0数据类型的了解。
    例1
     #include<stdio.h>
     #include<string.h>
     int main()
     {
          char c, s[20], *p;
          int a=1234, *i;
          float f=3.141592653589;
          double x=0.12345678987654321;
          p="How do you do";
          strcpy(s, "Hello, Comrade");
          *i=12;
          c='\x41';
          printf("a=%d\n", a);     /*结果输出十进制整数a=1234*/
          printf("a=%6d\n", a);    /*结果输出6位十进制数a=  1234*/
          printf("a=%06d\n", a);   /*结果输出6位十进制数a=001234*/
          printf("a=%2d\n", a);    /*a超过2位, 按实际值输出a=1234*/
          printf("*i=%4d\n", *i);  /*输出4位十进制整数*i=  12*/
          printf("*i=%-4d\n", *i); /*输出左对齐4位十进制整数*i=12*/
          printf("i=%p\n", i);     /*输出地址i=06E4*/
          printf("f=%f\n", f);     /*输出浮点数f=3.141593*/
          printf("f=6.4f\n", f);   /*输出6位其中小数点后4位的浮点数
                                      f=3.1416*/
          printf("x=%lf\n", x);    /*输出长浮点数x=0.123457*/
          printf("x=%18.16lf\n", x);/*输出18位其中小数点后16位的长浮点
                                      数x=0.1234567898765432*/
          printf("c=%c\n", c);     /*输出字符c=A*/
          printf("c=%x\n", c);     /*输出字符的ASCII码值c=41*/
          printf("s[]=%s\n", s);   /*输出数组字符串s[]=Hello, Comrade*/
          printf("s[]=%6.9s\n", s);/*输出最多9个字符的字符串s[]=Hello,
                                     Co*/
          printf("s=%p\n", s);     /*输出数组字符串首字符地址s=FFBE*/
          printf("*p=%s\n", p);    /* 输出指针字符串p=How do you do*/
          printf("p=%p\n", p);     /*输出指针的值p=0194*/
          getch();
          retunr 0;
     }
    上面结果中的地址值在不同计算机上可能不同。
    例1.中第一条语句#include<stdio.h>的含义是调用另一个文件stdio.h, 这
是一个头文件, 其中包括全部标准输入输出库函数的数据类型定义和函数说明。
Turbo C2.0对每个库函数便用的变量及函数类型都已作了定义与说明, 放在相应
头文件"*.h"中, 用户用到这些函数时必须要用#include<*.h>或#include"*. h"
语句调用相应的头文件, 以供连接。若没有用此语句说明, 则连接时将会出现错
误。
    二、scanf()函数
    scanf()函数是格式化输入函数, 它从标准输入设备(键盘) 读取输入的信息。
其调用格式为:
      scanf("<格式化字符串>", <地址表>);
    格式化字符串包括以下三类不同的字符;
    1. 格式化说明符: 格式化说明符与printf()函数中的格式说明符基本相同。
    2. 空白字符: 空白字符会使scanf()函数在读操作中略去输入中的一个或多
个空白字符。
    3. 非空白字符: 一个非空白字符会使scanf()函数在读入时剔除掉与这个非
空白字符相同的字符。
    地址表是需要读入的所有变量的地址, 而不是变量本身。这与printf()函数
完全不同, 要特别注意。各个变量的地址之间同","分开。
    例2:
     main()
     {
          int i, j;
          printf("i, j=?\n");
          scanf("%d, %d", &i, &j);
     }

    上例中的scanf()函数先读一个整型数, 然后把接着输入的逗号剔除掉,  最
后读入另一个整型数。如果","这一特定字符没有找到, scanf()函数就终止。若
参数之间的分隔符为空格, 则参数之间必须输入一个或多个空格。
    说明:
    (1). 对于字符串数组或字符串指针变量,  由于数组名和指针变量名本身就
是地址, 因此使用scanf()函数时, 不需要在它们前面加上"&"操作符。
    例3
      mian()
     {
          char *p, str[20];
          scanf("%s", p);          /*从健盘输入字符串*/
          scanf("%s", str);
          printf("%s\n", p);       /*向屏幕输出字符串*/
          printf("%s\n", str);
     }

    (2). 可以在格式化字符串中的"%"各格式化规定符之间加入一个整数, 表示
任何读操作中的最大位数。
    如例3中若规定只能输入10字符给字符串指针p, 则第一条scanf() 函数语句
变为
          scanf("%10s", p);
    程序运行时一旦输入字符个数大于10,  p就不再继续读入, 而后面的一个读
入函数即scanf("%s", str)就会从第11个字符开始读入。
    实际使用scanf()函数时存在一个问题, 下面举例进行说明:
    当使用多个scanf()函数连续给多个字符变量输入时, 例如:
     main()
     {
          char c1, c2;
          scanf("%c", &c1);
          scanf("%c", &c2);
          printf("c1 is %c, c2 is %c", c2\1, c2);
     }

    运行该程序, 输入一个字符A后回车 (要完成输入必须回车), 在执行scanf
("%c", &c1)时, 给变量c1赋值"A", 但回车符仍然留在缓冲区内, 执行输入语句
scanf("%c", &c2)时, 变量c2输出的是一空行, 如果输入AB后回车, 那么输出结
果为: c1 is A, c2 is B。
    要解决以上问题, 可以在输入函数前加入清除函数fflush()( 这个函数的使
用方法将在本节最后讲述)。修改以上程序变成:
     #include<stdio.h>
     main()
     {
          char c1, c2;
          scanf("%c", &c1);
          fflush(stdin);
          scanf("%c", &c2);
          printf("c1 is %c, c2 is %c", c1, c2);
     }

    1.1.2 非格式化输入输出函数
    非格式化输入输出函数可以由上面讲述的标准格式化输入输出函数代替, 但
这些函数编译后代码少, 相对占用内存也小, 从而提高了速度, 同时使用也比较
方便。下面分别进行介绍。
    一、puts()和gets()函数
    1. puts()函数
    puts()函数用来向标准输出设备(屏幕)写字符串并换行, 其调用格式为:
     puts(s);
    其中s为字符串变量(字符串数组名或字符串指针)。
    puts()函数的作用与语printf("%s\n", s)相同。
    例4:
     main()
     {
          char s[20], *f;                 /*定义字符串数组和指针变量*/
          strcpy(s, "Hello! Turbo C2.0"); /*字符串数组变量赋值*/
          f="Thank you";                  /*字符串指针变量赋值*/
          puts(s);
          puts(f);
     }

    说明:
    (1). puts()函数只能输出字符串, 不能输出数值或进行格式变换。
    (2). 可以将字符串直接写入puts()函数中。如:
          puts("Hello, Turbo C2.0");

    2. gets()函数
    gets()函数用来从标准输入设备(键盘)读取字符串直到回车结束, 但回车符
不属于这个字符串。其调用格式为:
    gets(s);
    其中s为字符串变量(字符串数组名或字符串指针)。
    gets(s)函数与scanf("%s", &s)相似, 但不完全相同, 使用scanf("%s", &s)
函数输入字符串时存在一个问题, 就是如果输入了空格会认为输入字符串结束,
空格后的字符将作为下一个输入项处理, 但gets() 函数将接收输入的整个字符
串直到回车为止。
    例5
     main()
     {
          char s[20], *f;
          printf("What's your name?\n");
          gets(s);                      /*等待输入字符串直到回车结束*/
          puts(s);                      /*将输入的字符串输出*/
          puts("How old are you?");
          gets(f);
          puts(f);
     }
    说明:
    (1). gets(s)函数中的变量s为一字符串。如果为单个字符,  编译连接不会
有错误, 但运行后会出现"Null pointer asignmemt"的错误。
 
    二、putchar()、getch()、getche()和getchar()函数
    1. putchar()函数
    putchar()函数是向标准输出设备输出一个字符, 其调用格式为:
     putchar(ch);
    其中ch为一个字符变量或常量。
    putchar()函数的作用等同于printf("%c", ch);
    例6:
     #include<stdio.h>
     main()
     {
          char c:             /*定义字符变量*/
          c='B';              /*给字符变量赋值*/
          putchar(c);         /*输出该字符*/
          putchar('\x42');    /*输出字母B*/
          putchar(0x42);      /*直接用ASCII码值输出字母B*/
     }
    从本例中的连续四个字符输出函数语句可以分清字符变量的不同赋值方法。
    2. getch()、getche()和getchar()函数
    (1) getch()和getche()函数
    这两个函数都是从键盘上读入一个字符。其调用格式为:
     getch();
     getche();
    两者的区别是: getch()函数不将读入的字符回显在显示屏幕上, 而getche()
函数却将读入的字符回显到显示屏幕上。
    例7:
     #include<stdio.h>
     main()
     {
          char c, ch;
          c=getch();     /*从键盘上读入一个字符不回显送给字符变量c*/
          putchar(c);    /*输出该字符*/
          ch=getche();   /*从键盘上带回显的读入一个字符送给字符变量ch*/
          putchar(ch);
     }
    利用回显和不回显的特点, 这两个函数经常用于交互输入的过程中完成暂停
等功能。
    例8:
     #include<stdio.h>
     main()
     {
          char c, s[20];
          printf("Name:");
          gets(s);
          printf("Press any key to confinue...");
          getch();  /*等待输入任一键*/
     }
 
    (2) getchar()函数
    getchar()函数也是从键盘上读入一个字符, 并带回显。它与前面两个函数
的区别在于: getchar()函数等待输入直到按回车才结束,  回车前的所有输入字
符都会逐个显示在屏幕上。但只有第一个字符作为函数的返回值。
    getchar()函数的调用格式为:
     getchar();
    例9:
     #include<stdio.h>
     main()
     {
          char c;
          c=getchar();   /*从键盘读入字符直到回车结束*/
          putchar(c);    /*显示输入的第一个字符*/
          getch();       /*等待按任一健*/
     }