周恒（zhouheng1212 ）的窝！(粗体字文章别删)

zhouheng1212 · 发表于 2006-8-21 11:31

标题: 债券词汇
发信站: 日月光华 (2003年05月29日19:02:48 星期四), 站内信件

场外债券市场：指没有固定场所的债券市场，交易通过电话或电脑网络直接在交易商和
委托人之间进行，不通过证券交易所，采用报价驱动制方式成交。

银行间债券市场：由中国人民银行建立的中国场外债券市场，建立初期成员为商业银行
，目前成员包括各类金融机构，交易品种为国债和政策性银行金融债券。

交易所债券市场：指通过证券交易所交易的债券市场，投资者的交易通过证券交易所撮
合，采用指令驱动制成交。

债券回购交易：卖方在卖出一种证券时，同意在未来某一约定日期，以约定价格购回该
证券的交易。

凭证式国债：财政部发行的记名国债，由商业银行销售，不能流通转让。

记账式国债：财政部发行的记名国债，在债券登记机构托管，可流通转让。

债券收益率及收益率曲线：债券收益率又称到期收益率，是使债券未来现金流的现值与
其市场价值相等的年利率。收益率曲线是在某一时点将不同于到期期限债券的收益率按
照时间排列的曲线，通常应用国债的收益率编制收益率曲线。

柜台交易系统：商业银行通过营业网点与投资人进行债券买卖的系统。

基准利率：在利率体系中对其他利率起到基准作用的利率。通常短期的基准利率是银行
间拆借和债券回购利率，中长期的基准利率是中长期国债的收益率。

做市商：在任一时点愿意按某一价格买进并按另一价格卖出足额的同一证券，从而实现
市场供求的平衡并可连续进行交易的机构。

可转换债：指有固定利率的债务工具，其持有人有权用债券和所余全部利息在事先约定
日期以事先约定的价格，向发行人换取事先确定数量的普通股或其他债务工具。

国债期货：以中长期国债为基础的期货合约，买卖双方约定，在将来某一特定日期反向
买卖国债，买卖双方须按一定的比例交付保证金。

标题: 通货紧缩
发信站: 日月光华 (2003年12月16日17:23:28 星期二)

国有银行在相当长的时期内仍将是资金配置的主渠道，但是其经营机制
和监管机制的转变滞后于银行体系的机构改革，尚未成为真正的商业银行和中央银
行。人民银行独立地位的确定和大区行的设置是银行体系机构改革的重要成绩，但
是国有银行机制的转变比机构改革更加重要。在商业银行改革完成之前，人民银行
旧的货币政策工具已经失效，新的货币政策工具尚不能充分发挥作用。如果国有商
业银行不能成为真正的商业银行，人民银行也就不能成为真正的中央银行。在负债业务领
域，国有银行之间展开过激烈竞争，而在资产业务和表外业务领域，国有银
行普遍动力不足，其原因在于内部存在着约束与激励的严重不对称：一方面，控制
风险的贷款约束机制已经建立并有效地控制着商业银行的经营风险，贷款员和审批
者个人对贷款承担终生责任直到贷款如数归还；另一方面，履行贷款职责的激励机
制尚未有效建立，拥有大量臃员的国有银行在分配机制上仍然是吃大锅饭。在这种
激励不足而约束有余的情况下，国有银行职员拓展资产业务领域和金融工具创新的
动力明显不足，不能满足市场经济对金融的要求，特别表现在两个方面：第一，对
中小企业和非国有企业的贷款业务远远滞后于这两类企业在发展过程中对金融的需
要；第二，扩张性的货币政策实效。中国人民银行将法定存款准备金率从13％下调
到8 ％，大大增加了各商业银行的可用资金头寸，连续调低存款准备金利率，从利
益上驱使商业银行扩大资产规模，增大货币乘数，可是相当一部分增加的银行可用
资金变成了超额储备和库存现金。

yaomingcctv · 发表于 2006-8-21 16:13

小子，一月不来都当老大了。。
好好干，
恕弟不能继续来聊了，且容闭关半年！
今来告别，相戏之时勿相忘！

小小背包 · 发表于 2006-8-21 21:57

周恒的帖子有价值..........赞一个............

四喜丸子^Q^ · 发表于 2006-8-21 22:20

周恒里面好多东东哦~~~~~

zhouheng1212 · 发表于 2006-8-22 09:53

到处溜达得到。

zhouheng1212 · 发表于 2006-8-22 11:24

标  题: DES算法的C实现（作者:小榕）
发信站: 一网深情 (Mon May 20 20:12:55 2002) , 站内信件

----------------------------------------
schedle.h
----------------------------------------
#include <windows.h>

DWORDLONG dwlKey_PC_1[64]={
57,49,41,33,25,17,9,
1,58,50,42,34,26,18,
10,2,59,51,43,35,27,
19,11,3,60,52,44,36,
63,55,47,39,31,23,15,
7,62,54,46,38,30,22,
14,6,61,53,45,37,29,
21,13,5,28,20,12,4,0};

DWORDLONG dwlKey_PC_2[64]={
14,17,11,24,1,5,
3,28,15,6,21,10,
23,19,12,4,26,8,
16,7,27,20,13,2,
41,52,31,37,47,55,
30,40,51,45,33,48,
44,49,39,56,34,53,
46,42,50,36,29,32,0};

DWORDLONG dwlData_IP[65]={
58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6,
64,56,48,40,32,24,16,8,
57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,0};

DWORDLONG dwlData_Expansion[64]={
32,1,2,3,4,5,
4,5,6,7,8,9,
8,9,10,11,12,13,
12,13,14,15,16,17,
16,17,18,19,20,21,
20,21,22,23,24,25,
24,25,26,27,28,29,
28,29,30,31,32,1,0};

DWORDLONG dwlData_P[33]={
16,7,20,21,
29,12,28,17,
1,15,23,26,
5,18,31,10,
2,8,24,14,
32,27,3,9,
19,13,30,6,
22,11,4,25,0};

DWORDLONG dwlData_FP[65]={
40,8,48,16,56,24,64,32,
39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,
37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,
35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,
33,1,41,9,49,17,57,25,0};

DWORDLONG OS[512]={
14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,
0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,
4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,
15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13,

15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9,

10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12,

7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14,

2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,
4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3,

12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13,

4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,
13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12,

13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11
};
-------------------------------------
des.cpp
-------------------------------------
-------------------------------------
/********************************************************************/
/*       DES(Data Encryption Standard)    */
/*       Written by Bunny       */
/*       Banyet Soft Labs. 1999       */
/*       ALL RIGHTS RESERVED!       */
/* 注意! 版权所有! 可以自由转载,但不得加以修改或删除!  */
/* E-mail:Assassin@ynmail.com  Http://Assassin.yeah.net  */
/********************************************************************/

/**************************************************************************/
/*注意:这只是标准DES算法的例子,所以速度并不是很快,不适用于大量数据加密的场*/
/*合.UNIX的密码也采用DES,不过它在里面加了点其它的东西.所以结果和DES的结果 */
/*不一样. 由于使用了WINDOWS类库,所以必须在WINDOWS环境下编译.    */
/**************************************************************************/

zhouheng1212 · 发表于 2006-8-22 11:25

#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <conio.h>
#include "Schedle.h"

class CShift{
public:
DWORDLONG mask[16];
int step[16];
CShift(){
for(int i=0;i<16;i++){
step[i]=2;
mask[i]=0xc000000;
}
step[0]=step[1]=step[8]=step[15]=1;
mask[0]=mask[1]=mask[8]=mask[15]=0x8000000;
}
};

class CDES{

public:

CDES(){
m_dwlKey=0;
m_dwlData=0;
ConvertTableToMask(dwlKey_PC_1,64);
//PrintTable(dwlKey_PC_1,7,8);
ConvertTableToMask(dwlKey_PC_2,56);
ConvertTableToMask(dwlData_IP,64);
ConvertTableToMask(dwlData_Expansion,32);
ConvertTableToMask(dwlData_FP,64);
ConvertTableToMask(dwlData_P,32);
Generate_S();

}
void PrintBit(DWORDLONG);
void EncryptKey(char *);
unsigned char* EncryptData(unsigned char *);
unsigned char* DescryptData(unsigned char*);

private:
void ConvertTableToMask(DWORDLONG *,int);
void Generate_S(void);
void PrintTable(DWORDLONG*,int,int);
DWORDLONG ProcessByte(unsigned char*,BOOL);
DWORDLONG PermuteTable(DWORDLONG,DWORDLONG*,int);
void Generate_K(void);
void EncryptKernel(void);
DWORDLONG Generate_B(DWORDLONG,DWORDLONG*);
/*For verify schedule permutation only*/
DWORDLONG UnPermuteTable(DWORDLONG,DWORDLONG*,int);
/**************************************/
DWORDLONG dwlData_S[9][4][16];
CShift m_shift;
DWORDLONG m_dwlKey;
DWORDLONG m_dwlData;
DWORDLONG m_dwl_K[17];
};

void CDES::EncryptKey(char *key){

printf("\nOriginal Key: %s",key);
m_dwlKey=ProcessByte((unsigned char*)key,TRUE);
// PrintBit(m_dwlKey);
m_dwlKey=PermuteTable(m_dwlKey,dwlKey_PC_1,56);
// PrintBit(m_dwlKey);
Generate_K();
// printf("\n******************************************\n");
}

void CDES::Generate_K(void){

DWORDLONG C[17],D[17],tmp;

C[0]=m_dwlKey>>28;
D[0]=m_dwlKey&0xfffffff;

for(int i=1;i<=16;i++){
tmp=(C[i-1]&m_shift.mask[i-1])>>(28-m_shift.step[i-1]);
C[i]=((C[i-1]<<m_shift.step[i-1])|tmp)&0x0fffffff;
tmp=(D[i-1]&m_shift.mask[i-1])>>(28-m_shift.step[i-1]);
D[i]=((D[i-1]<<m_shift.step[i-1])|tmp)&0x0fffffff;
m_dwl_K[i]=(C[i]<<28)|D[i];
m_dwl_K[i]=PermuteTable(m_dwl_K[i],dwlKey_PC_2,48);
}
}

DWORDLONG CDES:

rocessByte(unsigned char *key,BOOL shift){

unsigned char tmp;
DWORDLONG byte=0;
int i=0;

while(i<8){
while(*key){
if(byte!=0)
byte<<=8;
tmp=*key;
if(shift)
tmp<<=1;
byte|=tmp;
i++;
key++;
}
if(i<8)
byte<<=8;
i++;
}
return byte;
}

DWORDLONG CDES::PermuteTable(DWORDLONG dwlPara,DWORDLONG* dwlTable,int nDestLen)
{

int i=0;
DWORDLONG tmp=0,moveBit;

while(i<nDestLen){
moveBit=1;
if(dwlTable[i]&dwlPara){
moveBit<<=nDestLen-i-1;
tmp|=moveBit;
}
i++;
}
return tmp;
}

DWORDLONG CDES::UnPermuteTable(DWORDLONG dwlPara,DWORDLONG* dwlTable,int nDestLe
n){

DWORDLONG tmp=0;
int i=nDestLen-1;

while(dwlPara!=0){
if(dwlPara&0x01)
tmp|=dwlTable[i];
dwlPara>>=1;
i--;
}
return tmp;
}

void CDES::PrintTable(DWORDLONG *dwlPara,int col,int row){

int i,j;
for(i=0;i<row;i++){
printf("\n");
getch();
for(j=0;j<col;j++)
PrintBit(dwlPara[i*col+j]);
}
}

void CDES::PrintBit(DWORDLONG bitstream){

char out[76];
int i=0,j=0,space=0;

while(bitstream!=0){
if(bitstream&0x01)
out[i++]='1';
else
out[i++]='0';
j++;
if(j%8==0){
out[i++]=' ';
space++;
}

bitstream=bitstream>>1;
}
out[i]='\0';
strcpy(out,strrev(out));
printf("%s **:%d\n",out,i-space);
}

void CDES::ConvertTableToMask(DWORDLONG *mask,int max){

int i=0;
DWORDLONG nBit=1;

while(mask[i]!=0){
nBit=1;
nBit<<=max-mask[i];
mask[i++]=nBit;
}
}

void CDES::Generate_S(void){

int i;
int j,m,n;
m=n=0;
j=1;

for(i=0;i<512;i++){
dwlData_S[j][m][n]=OS[i];
n=(n+1)%16;
if(!n){
m=(m+1)%4;
if(!m)
j++;
}
}
}

unsigned char * CDES::EncryptData(unsigned char *block){

unsigned char *EncrytedData=new unsigned char(15);

printf("\nOriginal Data: %s\n",block);
m_dwlData=ProcessByte(block,0);
// PrintBit(m_dwlData);
m_dwlData=PermuteTable(m_dwlData,dwlData_IP,64);
EncryptKernel();
// PrintBit(m_dwlData);
DWORDLONG bit6=m_dwlData;
for(int i=0;i<11;i++){
EncrytedData[7-i]=(unsigned char)(bit6&0x3f)+46;
bit6>>=6;
}
EncrytedData[11]='\0';
printf("\nAfter Encrypted: %s",EncrytedData);

for(i=0;i<8;i++){
EncrytedData[7-i]=(unsigned char)(m_dwlData&0xff);
m_dwlData>>=8;
}
EncrytedData[8]='\0';

return EncrytedData;
}

void CDES::EncryptKernel(void){

int i=1;

DWORDLONG L[17],R[17],B[9],EK,PSB;
L[0]=m_dwlData>>32;
R[0]=m_dwlData&0xffffffff;

for(i=1;i<=16;i++){
L[i]=R[i-1];
R[i-1]=PermuteTable(R[i-1],dwlData_Expansion,48); //Expansion R
EK=R[i-1]^m_dwl_K[i]; //E Permutation
PSB=Generate_B(EK,B); //P Permutation
R[i]=L[i-1]^PSB;
}

R[16]<<=32;
m_dwlData=R[16]|L[16];
m_dwlData=PermuteTable(m_dwlData,dwlData_FP,64);
}

unsigned char* CDES:

escryptData(unsigned char *desData){

int i=1;
unsigned char *DescryptedData=new unsigned char(15);
DWORDLONG L[17],R[17],B[9],EK,PSB;
DWORDLONG dataPara;

dataPara=ProcessByte(desData,0);
dataPara=PermuteTable(dataPara,dwlData_IP,64);

R[16]=dataPara>>32;
L[16]=dataPara&0xffffffff;

for(i=16;i>=1;i--){
R[i-1]=L[i];
L[i]=PermuteTable(L[i],dwlData_Expansion,48); //Expansion L
EK=L[i]^m_dwl_K[i]; //E Permutation
PSB=Generate_B(EK,B); //P Permutation
L[i-1]=R[i]^PSB;
}

L[0]<<=32;
dataPara=L[0]|R[0];
dataPara=PermuteTable(dataPara,dwlData_FP,64);

// PrintBit(dataPara);

for(i=0;i<8;i++){
DescryptedData[7-i]=(unsigned char)(dataPara&0xff);
dataPara>>=8;
}
DescryptedData[8]='\0';
printf("\nAfter Decrypted: %s\n",DescryptedData);

return DescryptedData;
}

DWORDLONG CDES::Generate_B(DWORDLONG EKPara,DWORDLONG *block){

int i,m,n;
DWORDLONG tmp=0;

for(i=8;i>0;i--){
block[i]=EKPara&0x3f;
m=(int)(block[i]&0x20)>>4;
m|=block[i]&0x01;
n=(int)(block[i]<<1)>>2;
block[i]=dwlData_S[i][m][n];
EKPara>>=6;
}

for(i=1;i<=8;i++){
tmp|=block[i];
tmp<<=4;
}
tmp>>=4;
tmp=PermuteTable(tmp,dwlData_P,32);

return tmp;
}

void main(void){

CDES des;
des.EncryptKey("*");
unsigned char *result=des.EncryptData((unsigned char*)"DemoData");
des.DescryptData(result);
}

zhouheng1212 · 发表于 2006-8-22 11:25

标  题: 前不久自己写的小游戏（俄罗斯方块与贪吃蛇）
发信站: 一网深情 (2002年07月27日00:06:55 星期六), 站内信件

（作者:silitek）

应版主的要求,我把说明文档及源代码公布在下面。
两个游戏均在VC6下编译通过且运行良好,代码共四个文件，
其中包括三个h文件和一个cpp文件:

文件名          描述

canvas.h    定义画布类，为两个游戏公用
russia_game.h    定义Russsia类，俄罗斯方块程序使用
snake_game.h    定义snake类，贪吃蛇程序使用
snake_and_russia.cpp 主程序

现分别贴在下面:

1.canvas.h

//canvas.h

eclare a canvas class .this class can be use in
//    windows program to create a canvas and draw some dots
//    on it.It is a kide of a dot-array canvas.Some game can
//    based on this class.You can use this class to write
//    some "dot_array_based game" easily.
//
//date :2002.7.20
//Author :EarlyBird
//
//rights :you can use this class freely.
#include <algorithm>
#include <assert.h>
#include <windows.h>
#include <algorithm> // To use abs() and min()
using namespace std;
const COLORREF RED=RGB(255,0,0);//  define some  color definition
const COLORREF GREEN= RGB(0,255,0);
const COLORREF  BLUE=RGB(0,0,255);
const COLORREF  WRITE=RGB(255,255,255);
const COLORREF BLACK= RGB(0,0,0);
const COLORREF ORANGE=RGB(56,112,169);
class dot  // dot class
{
public:
  dot();
  bool visible;  //two characters :visible and dot's color
  COLORREF color;
};
dot::dot()
{

}
////////////////////////////////
class canvas //canvas class
{
public:
  canvas(HWND hWnd,HDC hDC);
  //Create a canvas.
  //You must transfer the HWND and HDC handles
  //of the aim Window to the canvas
  inline  dot& dot_at(int x,int y); //return the dot
  inline  bool show_dot(int x,int y,COLORREF c=BLACK);
  bool initilize(int m,int n,RECT clinet_rect,COLORREF bc=WRITE,COLORREF
fc=B
LACK);
/*To initlize the canvas.Parameter m and n is to define a dot_array as a M*N
  array. And parameter client_rect is to define the rect of the all canvas.And
  parameter fc is fore_color and the bc is the back_color;  */
  inline bool hide_dot(int x,int y);//hide a dot;
  void cls();  //hide all dot;
  void flash(); //show all the visible dot
  void show_all(COLORREF c=BLACK);//show all the dot
  bool show_line(int x1,int y1,int x2,int y2,COLORREF c=BLACK);
  //show a line
  bool hide_line(int x1,int y1,int x2,int y2);
  //hide a line if the dot on line vislble
  void set_back_color(COLORREF c){back_color=c;}
  COLORREF get_back_color(){return back_color;}
  void set_fore_color(COLORREF c){fore_color=c;}
  COLORREF get_fore_color(){return fore_color;}
  bool show_by_array( POINT* array,int num,COLORREF c);
  //show dots that stored in a array
  bool hide_by_array( POINT* array,int num);
  COLORREF get_dot_color(int x,int y)
  {return dot_at(x,y).color;}
  void show_border(COLORREF c=ORANGE);
  //show the canvas border
  void change_by_array(POINT* hide,int mh,POINT *show,int ms,COLORREF
c=BLACK
);
  //此函数是用于扫除第一个数组定义的点并显示第二个数组定义的点,
  //此个函数主要是为了切换的时候用算法实现平滑过渡防止闪烁.
protected:
  HWND hwnd;
  HDC hdc;
  int M;
  int N;  //M*N dot array;
COLORREF back_color;
COLORREF fore_color;
  RECT canvas_rect; //rect of window;
  dot* dot_array;  //pointer to the dot_array;
  RECT* rect_array;//pointer to the rect_array;
  HBRUSH fore_brush; //two color brush
  HBRUSH back_brush;
  RECT borderx;
  RECT bordery;
};
//////////////////////////////////
canvas::canvas(HWND hWnd,HDC hDC)
{
  hwnd=hWnd;
  hdc=hDC;
}
///////////////////////////////////
bool canvas::initilize(int m,int n,RECT client_rect,COLORREF bc,COLORREF fc)

{
  assert(m>0&&n>0);
  M=m;N=n;
  canvas_rect=client_rect;
  back_color=bc;
  fore_color=fc;
  dot_array=new dot[M*N];
  for (int i=0;i<M*N;i++)
  {
dot_array[i].visible =false;
dot_array[i].color=back_color;
  }

  rect_array=new RECT[M*N];
  int dot_x_width=int((canvas_rect.right-canvas_rect.left)/M);
  int dot_y_width=int((canvas_rect.bottom-canvas_rect.top)/N);
  for (int j=0;j<M;j++)
  for (int k=0;k<N;k++)
  {
rect_array[j*N+k].left=canvas_rect.left+j*dot_x_width;
rect_array[j*N+k].right=rect_array[j*N+k].left+dot_x_width-1;
rect_array[j*N+k].top=canvas_rect.top+k*dot_y_width;
rect_array[j*N+k].bottom=rect_array[j*N+k].top+dot_y_width-1;
  }
  borderx.left =0;
  borderx.right=rect_array[M*N-1].right +dot_x_width;
  borderx.top =rect_array[M*N-1].bottom;
  borderx.bottom =borderx.top+dot_x_width;
  bordery.left =rect_array[M*N-1].right;
  bordery.right =bordery.left+dot_x_width;
  bordery.top =0;
  bordery.bottom =borderx.bottom ;
  fore_brush=CreateSolidBrush(fore_color);
  back_brush=CreateSolidBrush(back_color);
  show_border();
  return true;
}
////////////////////////////
inline dot& canvas::dot_at(int x,int y)
{
  return dot_array[x*N+y];
}
inline bool canvas::show_dot(int x,int y,COLORREF c)
{
  if(dot_at(x,y).visible==false)
  {
dot_at(x,y).color=c;
dot_at(x,y).visible=true;
if(c==fore_color)
{
FillRect(hdc,&rect_array[x*N+y],fore_brush);
}
else
{
HBRUSH temp=CreateSolidBrush(c);
FillRect(hdc,&rect_array[x*N+y],temp);
DeleteObject(temp);
}

return true;
  }
  if(dot_at(x,y).visible==true&&dot_at(x,y).color!=c)
  {
dot_at(x,y).color=c;
HBRUSH temp=CreateSolidBrush(c);
FillRect(hdc,&rect_array[x*N+y],temp);
DeleteObject(temp);
return true;
  }
  return false;
}
//////////////////////////////////////////
inline bool canvas::hide_dot(int x,int y)
{
  if (dot_at(x,y).visible==true)
  {
dot_at(x,y).visible=false;
dot_at(x,y).color=back_color;
FillRect(hdc,&rect_array[x*N+y],back_brush);
return true;
  }
  else
  {
return false;
  }
}
//////////////////////////////////////////////
void canvas::cls()
{
  for (int i=0;i<M;i++)
  for (int j=0;j<N;j++)
  {
dot_at(i,j).visible =false;
dot_at(i,j).color=back_color;

  }
  FillRect(hdc,&canvas_rect,back_brush);
  show_border();
}
////////////////////////////////////////////////
void canvas::show_all(COLORREF c)
{
  for (int i=0;i<M;i++)
  for (int j=0;j<N;j++)
  {show_dot(i,j,c);

  }

//  HBRUSH temp=CreateSolidBrush(c);
//  FillRect(hdc,&canvas_rect,temp);

}
/////////////////////////////////////////////
bool canvas::show_line(int x1,int y1,int x2,int y2,COLORREF c)
{

  if(x1==x2&&y1==y2)
  {
show_dot(x1,y1,c);
  }
  if(!(x1==x2&&y1==y2))
  {
  int dx=abs(x1-x2);
  int dy=abs(y1-y2);

  int tempx;int tempy;
  int directorx;int directory;
  if(dx==0)
directorx=0;
  else
directorx=(x2-x1)/dx;
  //////////////////
  if (dy==0)
directory=0;
  else
directory=(y2-y1)/dy;

  float tempd;
  if (dx>dy)
  {

tempd=float(dy)/float(dx);
for (int i=0;i<dx;i++)
{
tempx=i*directorx+x1;
tempy=y1+directory*int(i*tempd);
show_dot(tempx,tempy,c);
}

  }
  else
  {
tempd=float(dx)/float(dy);
for(int j=0;j<dy;j++)
{
tempx=x1+directorx*int(j*tempd);
tempy=j*directory+y1;
show_dot(tempx,tempy,c);
}
  }
  }
return true;
}
/////////////////////////////////////////////////////
bool canvas::hide_line(int x1,int y1,int x2,int y2)
{
if(x1==x2&&y1==y2)
  {
if(dot_at(x1,y1).visible==true)
hide_dot(x1,y1);
  }
  if(!(x1==x2&&y1==y2))
  {
  int dx=abs(x1-x2);
  int dy=abs(y1-y2);

  int tempx;int tempy;
  int directorx;int directory;
  if(dx==0)
directorx=0;
  else
directorx=(x2-x1)/dx;
  //////////////////
  if (dy==0)
directory=0;
  else
directory=(y2-y1)/dy;

  float tempd;
  if (dx>dy)
  {

tempd=float(dy)/float(dx);
for (int i=0;i<dx;i++)
{
tempx=i*directorx+x1;
tempy=y1+directory*int(i*tempd);
if (dot_at(tempx,tempy).visible ==true)
hide_dot(tempx,tempy);
}

  }
  else
  {
tempd=float(dx)/float(dy);
for(int j=0;j<dy;j++)
{
tempx=x1+directorx*int(j*tempd);
tempy=j*directory+y1;
if (dot_at(tempx,tempy).visible ==true)
hide_dot(tempx,tempy);
}
  }
  }
return true;
}
///////////////////////////////////////////////////////
bool canvas::show_by_array( POINT* array,int num,COLORREF c)
{
  if (num==0)
return false;
  else
  {
for (int i=0;i<num ;i++)
{
show_dot(array[i].x,array[i].y,c);
}
return true;
  }
}
bool canvas::hide_by_array( POINT* array,int num)
{
  if (num==0)
return false;
  else
  {
for (int i=0;i<num ;i++)
{
if (dot_at(array[i].x,array[i].y).visible==true)
hide_dot(array[i].x,array[i].y);
}
return true;
  }
}
///////////////////////////////////////////////////
void canvas::flash()
{
  COLORREF temp;
  HBRUSH temp_brush;
  temp=dot_at(0,0).color;
  temp_brush=CreateSolidBrush(temp);
  for (int i=0;i<M;i++)
  for (int j=0;j<N;j++)
  {
{
if (temp!=dot_at(i,j).color)
{
   DeleteObject(temp_brush);
   temp=dot_at(i,j).color;
   temp_brush=CreateSolidBrush(temp);
}
FillRect(hdc,&rect_array[i*N+j],temp_brush);
}
  }
  DeleteObject(temp_brush);
  show_border();
}
///////////////////////////////
void canvas::show_border(COLORREF c)
{
  HBRUSH border_brush=CreateSolidBrush(c);
  FillRect(hdc,&borderx,border_brush);
  FillRect(hdc,&bordery,border_brush);
DeleteObject(border_brush);
}
///////////////////////////////////////////
bool dot_in_array(POINT dot,POINT* array,int n)
{

  for (int i=0;i<n;i++)
  {
if (dot.x==array[i].x&&dot.y==array[i].y)
return true;

  }
  return false;
}
///////////////////////////////////////////
void canvas::change_by_array(POINT* hide,int mh,POINT *show,int ms,COLORREFc)
{
  int hide_num=0;
  POINT* hide_array=new POINT[mh];

  for (int i=0;i<mh;i++)
  {
if(!dot_in_array(hide[i],show,ms))
{
hide_array[hide_num].x=hide[i].x;
hide_array[hide_num].y=hide[i].y;
hide_num++;
}
  }
  show_by_array(show,ms,c);
  hide_by_array(hide_array,hide_num);

  delete[] hide_array;
}
--

zhouheng1212 · 发表于 2006-8-22 11:30

标  题: 竞赛题型归纳
发信站: 珞珈山水 ( 2003年03月20日15:46:14 星期四), 站内信件

Hal Burch把竞赛题型归纳为以下16种:

Dynamic Programming    动态规划
Greedy       贪心法
Complete Search    枚举法
Flood Fill       染色法
Shortest Path    最短路径
Recursive Search Techniques 递归搜索
Minimum Spanning Tree    最小生成数
Knapsack       背包问题
Computational Geometry 计算几何学
Network Flow       网络流
Eulerian Path    欧拉路径
Two-Dimensional Convex Hull 二维凸包
BigNums       高精度计算
Heuristic Search    启发式搜索
Approximate Search    近似搜索
Ad Hoc Problems    特殊问题

这个分类不一定权威，不过我想可供大家对照整理自己的知识结构

)
（中文是我加上去的，欢迎指正^^）

zhouheng1212 · 发表于 2006-8-22 11:31

标  题: 数论难题100道
发信站: 珞珈山水 (2003年06月14日21:44:21 星期六), 站内信件

第01题  阿基米德分牛问题Archimedes' Problema Bovinum
太阳神有一牛群，由白、黑、花、棕四种颜色的公、母牛组成。
在公牛中，白牛数多于棕牛数，多出之数相当于黑牛数的1/2+1/3；黑牛数多于
棕牛
，多出之数相当于花牛数的1/4+1/5；花牛数多于棕牛数，多出之数相当于白牛
数的
1/6+1/7。
在母牛中，白牛数是全体黑牛数的1/3+1/4；黑牛数是全体花牛数1/4+1/5；花
牛数
是全体棕牛数的1/5+1/6；棕牛数是全体白牛数的1/6+1/7。
问这牛群是怎样组成的？
第02题  德·梅齐里亚克的法码问题The Weight Problem of Bachet de
Meziriac
一位商人有一个40磅的砝码，由于跌落在地而碎成4块.后来，称得每块碎片的
重量都
是整磅数，而且可以用这4块来称从1至40磅之间的任意整数磅的重物。
问这4块砝码碎片各重多少？
第03题  牛顿的草地与母牛问题Newton's Problem of the Fields and Cows
a头母牛将b块地上的牧草在c天内吃完了；
a'头母牛将b'块地上的牧草在c'天内吃完了；
a"头母牛将b"块地上的牧草在c"天内吃完了；
求出从a到c"9个数量之间的关系？
第04题  贝韦克的七个7的问题Berwick's Problem of the Seven Sevens
在下面除法例题中，被除数被除数除尽:
* * 7 * * * * * * * ÷ * * * * 7 * = * * 7 * *
* * * * * *
* * * * * 7 *
* * * * * * *
* 7 * * * *
* 7 * * * *
* * * * * * *
* * * * 7 * *
   * * * * * *
   * * * * * *
用星号（*）标出的那些数位上的数字偶然被擦掉了，那些不见了的是些什么数
字呢
？
第05题  柯克曼的女学生问题Kirkman's Schoolgirl Problem
某寄宿学校有十五名女生，她们经常每天三人一行地散步，问要怎样安排才能
使每
个女生同其他每个女生同一行中散步，并恰好每周一次？
第06题  伯努利-欧拉关于装错信封的问题The Bernoulli-Euler Problem of
the Misa
ddressed letters
求n个元素的排列，要求在排列中没有一个元素处于它应当占有的位置。
第07题  欧拉关于多边形的剖分问题Euler's Problem of Polygon Division
可以有多少种方法用对角线把一个n边多边形（平面凸多边形）剖分成三角形？

第08题  鲁卡斯的配偶夫妇问题Lucas' Problem of the Married Couples
n对夫妇围圆桌而坐，其座次是两个妇人之间坐一个男人，而没有一个男人和自
己的

妻子并坐，问有多少种坐法？
第09题  卡亚姆的二项展开式Omar Khayyam's Binomial Expansion
当n是任意正整数时，求以a和b的幂表示的二项式a+b的n次幂。
第10题  柯西的平均值定理Cauchy's Mean Theorem
求证n个正数的几何平均值不大于这些数的算术平均值。
第11题  伯努利幂之和的问题Bernoulli's Power Sum Problem
确定指数p为正整数时最初n个自然数的p次幂的和S=1p+2p+3p+…+np。
第12题  欧拉数The Euler Number
求函数φ(x)=(1+1/x)x及Φ(x)=(1+1/x)x+1当x无限增大时的极限值。
第13题  牛顿指数级数Newton's Exponential Series
将指数函数ex变换成各项为x的幂的级数。
第14题  麦凯特尔对数级数Nicolaus Mercator's Logarithmic Series
不用对数表，计算一个给定数的对数。
第15题  牛顿正弦及余弦级数Newton's Sine and Cosine Series
不用查表计算已知角的正弦及余弦三角函数。
第16题  正割与正切级数的安德烈推导法Andre's Derivation of the Secant and
Tan
gent Series
在n个数1，2，3，…,n的一个排列c1，c2，…，cn中，如果没有一个元素ci的
值介于
两个邻近的值ci-1和 ci+1之间，则称c1，c2，…，cn为1，2，3，…,n的一个屈
折排
列。
试利用屈折排列推导正割与正切的级数。
第17题  格雷戈里的反正切级数Gregory's Arc Tangent Series
已知三条边，不用查表求三角形的各角。
第18题  德布封的针问题Buffon's Needle Problem
在台面上画出一组间距为d的平行线，把长度为l（小于d）的一根针任意投掷在
台面

  上，问针触及两平行线之一的概率如何？
第19题  费马-欧拉素数定理The Fermat-Euler Prime Number Theorem
每个可表示为4n+1形式的素数，只能用一种两数平方和的形式来表示。
第20题  费马方程The Fermat Equation
求方程x2－dy2=1的整数解，其中d为非二次正整数。
第21题  费马-高斯不可能性定理The Fermat-Gauss Impossibility Theorem
证明两个立方数的和不可能为一立方数。
第22题  二次互反律The Quadratic Reciprocity Law
（欧拉-勒让德-高斯定理）奇素数p与q的勒让德互反符号取决于公式
（p/q）·（q/p）=（－1）[(p-1)/2]·[(q-1)/2]
第23题  高斯的代数基本定理Gauss' Fundamental Theorem of Algebra
每一个n次的方程zn+c1zn-1+c2zn-2+…+cn=0具有n个根。
第24题  斯图谟的根的个数问题Sturm's Problem of the Number of Roots
求实系数代数方程在已知区间上的实根的个数。
第25题  阿贝尔不可能性定理Abel's Impossibility Theorem
高于四次的方程一般不可能有代数解法。
第26题  赫米特-林德曼超越性定理The Hermite-Lindemann Transcedence
Theorem
系数A不等于零，指数α为互不相等的代数数的表达式A1eα1+A2eα2+A3eα3+
…不
可能等于零。
第27题  欧拉直线Euler's Straight Line
在所有三角形中，外接圆的圆心，各中线的交点和各高的交点在一直线—欧拉
线上，
而且三点的分隔为:各高线的交点（垂心）至各中线的交点（重心）的距离两
倍于外
接圆的圆心至各中线的交点的距离。
第28题  费尔巴哈圆The Feuerbach Circle
三角形中三边的三个中点、三个高的垂足和高的交点到各顶点的线段的三个中
点在一
个圆上。
第29题  卡斯蒂朗问题Castillon's Problem
将各边通过三个已知点的一个三角形内接于一个已知圆。
第30题  马尔法蒂问题Malfatti's Problem
在一个已知三角形内画三个圆，每个圆与其他两个圆以及三角形的两边相切。

第31题  蒙日问题Monge's Problem
画一个圆，使其与三已知圆正交。
第32题  阿波洛尼斯相切问题The Tangency Problem of Apollonius
画一个与三个已知圆相切的圆。
第33题  马索若尼圆规问题Macheroni's Compass Problem
证明任何可用圆规和直尺所作的图均可只用圆规作出。
第34题  斯坦纳直尺问题Steiner's Straight-edge Problem
证明任何一个可以用圆规和直尺作出的图，如果在平面内给出一个定圆，只用
直尺便
可作出。
第35题  德里安倍立方问题The Deliaii Cube-doubling Problem
画出体积为一已知立方体两倍的立方体的一边。
第36题  三等分一个角Trisection of an Angle
把一个角分成三个相等的角。
第37题  正十七边形The Regular Heptadecagon
画一正十七边形。
第38题  阿基米德π值确定法Archimedes' Determination of the Number
Pi{/color]

设圆的外切和内接正2vn边形的周长分别为av和bv，便依次得到多边形周长的阿
基米
德数列:a0，b0，a1， b1，a2，b2，…其中av+1是av、bv的调和中项，bv+1是
bv、a
v+1的等比中项。假如已知初始两项，利用这个规则便能计算出数列的所有项。
这个
方法叫作阿基米德算法。
第39题  富斯弦切四边形问题Fuss' Problem of the Chord-Tangent
Quadrilateral
找出半径与双心四边形的外接圆和内切圆连心线之间的关系。（注:一个双心
或弦切
四边形的定义是既内接于一个圆而同时又外切于另一个圆的四边形）
第40题  测量附题Annex to a Survey
利用已知点的方位来确定地球表面未知但可到达的点的位置。
第41题  阿尔哈森弹子问题Alhazen's Billiard Problem
在一个已知圆内，作出一个其两腰通过圆内两个已知点的等腰三角形。
第42题  由共轭半径作椭圆An Ellipse from Conjugate Radii
已知两个共轭半径的大小和位置，作椭圆。
第43题  在平行四边形内作椭圆An Ellipse in a Parallelogram
在规定的平行四边形内作一内切椭圆，它与该平行四边形切于一边界点。
第44题  由四条切线作抛物线A Parabola from Four Tangents
已知抛物线的四条切线，作抛物线。
第45题  由四点作抛物线A Parabola from Four Points
过四个已知点作抛物线。
第46题  由四点作双曲线A Hyperbola from Four Points
已知直角（等轴）双曲线上四点，作出这条双曲线。
第47题  范·施古登轨迹题Van Schooten's Locus Problem
平面上的固定三角形的两个顶点沿平面上一个角的两个边滑动，第三个顶点的
轨迹是
什么？
第48题  卡丹旋轮问题Cardan's Spur Wheel Problem
一个圆盘沿着半径为其两倍的另一个圆盘的内缘滚动时，这个圆盘上标定的一
点所描
出的轨迹是什么？
第49题  牛顿椭圆问题Newton's Ellipse Problem
确定内切于一个已知（凸）四边形的所有椭圆的中心的轨迹。
第50题  彭赛列-布里昂匈双曲线问题The Poncelet-Brianchon Hyperbola
Problem
确定内接于直角（等边）双曲线的所有三角形的顶垂线交点的轨迹。
第51题  作为包络的抛物线A Parabola as Envelope
从角的顶点，在角的一条边上连续n次截取任意线段e，在另一条边上连续n次截
取线
段f，并将线段的端点注以数字，从顶点开始，分别为0，1，2，…，n和n，n－
1，…
，2，1，0。
求证具有相同数字的点的连线的包络为一条抛物线。
第52题  星形线The Astroid
直线上两个标定的点沿着两条固定的互相垂直的轴滑动，求这条直线的包络。

第53题  斯坦纳的三点内摆线Steiner's Three-pointed Hypocycloid
确定一个三角形的华莱士（Wallace）线的包络。
第54题.一个四边形的最接近圆的外接椭圆The Most Nearly Circular Ellipse
Circum
scribing a Quadrilateral
一个已知四边形的所有外接椭圆中，哪一个与圆的偏差最小？
第55题  圆锥曲线的曲率The Curvature of Conic Sections
确定一个圆锥曲线的曲率。
第56题  阿基米德对抛物线面积的推算Archimedes' Squaring of a Parabola
确定包含在抛物线内的面积。
第57题  推算双曲线的面积Squaring a Hyperbola
确定双曲线被截得的部分所含的面积。
第58题  求抛物线的长Rectification of a Parabola
确定抛物线弧的长度。
第59题  笛沙格同调定理（同调三角形定理）Desargues' Homology Theorem
(Theorem of Homologous Triangles)
如果两个三角形的对应顶点连线通过一点，则这两个三角形的对应边交点位于
一条直
线上。反之，如果两个三角形的对应边交点位于一条直线上，则这两个三角形
的对应
顶点连线通过一点。
第60题  斯坦纳的二重元素作图法Steiner's Double Element Construction
由三对对应元素所给定的重迭射影形，作出它的二重元素。
第61题  帕斯卡六边形定理Pascal's Hexagon Theorem
求证内接于圆锥曲线的六边形中，三双对边的交点在一直线上。
第62题  布里昂匈六线形定理Brianchon's Hexagram Theorem
求证外切于圆锥曲线的六线形中，三条对顶线通过一点。
第63题  笛沙格对合定理Desargues' Involution Theorem
一条直线与一个完全四点形*的三双对边的交点与外接于该四点形的圆锥曲线构
成一
个对合的四个点偶。一个点与一个完全四线形*的三双对顶点的连线和从该点向
内切
于该四线形的圆锥曲线所引的切线构成一个对合的四个射线偶。
  *一个完全四点形（四线形）实际上含有四点（线）1，2，3，4和它们的六条连
线交点
23，14，31，24，12  ，34；其中23与14、31与24、12与34称为对边（对顶点
）。

第64题  由五个元素得到的圆锥曲线A Conic Section from Five Elements
求作一个圆锥曲线，它的五个元素——点和切线——是已知的。
第65题  一条圆锥曲线和一条直线A Conic Section and a Straight Line
一条已知直线与一条具有五个已知元素——点和切线——的圆锥曲线相交，求
作它们
的交点。
第66题  一条圆锥曲线和一定点A Conic Section and a Point
已知一点及一条具有五个已知元素——点和切线——的圆锥曲线，作出从该点
列到该
曲线的切线。
第67题  斯坦纳的用平面分割空间Steiner's Division of Space by Planes
n个平面最多可将整个空间分割成多少份？
第68题  欧拉四面体问题Euler's Tetrahedron Problem
以六条棱表示四面体的体积。
第69题  偏斜直线之间的最短距离The Shortest Distance Between Skew Lines
计算两条已知偏斜直线之间的角和距离。
第70题  四面体的外接球The Sphere Circumscribing a Tetrahedron
确定一个已知所有六条棱的四面体的外接球的半径。
第71题  五种正则体The Five Regular Solids
将一个球面分成全等的球面正多边形。
第72题  正方形作为四边形的一个映象The Square as an Image of a
Quadrilateral
证明每个四边形都可以看作是一个正方形的透视映象。
第73题  波尔凯-许瓦尔兹定理The Pohlke-Schwartz Theorem
一个平面上不全在同一条直线上的四个任意点，可认为是与一个已知四面体相
似的四
面体的各隅角的斜映射。
第74题  高斯轴测法基本定理Gauss' Fundamental Theorem of Axonometry
正轴测法的高斯基本定理:如果在一个三面角的正投影中，把映象平面作为复
平面，
三面角顶点的投影作为零点，边的各端点的投影作为平面的复数，那么这些数
的平方
和等于零。
第75题  希帕查斯球极平面射影Hipparchus' Stereographic Projection
试举出一种把地球上的圆转换为地图上圆的保形地图射影法。
第76题  麦卡托投影The Mercator Projection
画一个保形地理地图，其坐标方格是由直角方格组成的。
第77题  航海斜驶线问题The Problem of the Loxodrome
确定地球表面两点间斜驶线的经度。
第78题  海上船位置的确定Determining the Position of a Ship at Sea
利用天文经线推算法确定船在海上的位置。
第79题  高斯双高度问题Gauss' Two-Altitude Problem
根据已知两星球的高度以确定时间及位置。
第80题  高斯三高度问题Gauss' Three-Altitude Problem
从在已知三星球获得同高度瞬间的时间间隔，确定观察瞬间，观察点的纬度及
星球的
高度。
第81题  刻卜勒方程The Kepler Equation
根据行星的平均近点角，计算偏心及真近点角。
第82题  星落Star Setting
对给定地点和日期，计算一已知星落的时间和方位角。
第83题  日晷问题The Problem of the Sundial
制作一个日晷。
第84题  日影曲线The Shadow Curve
当直杆置于纬度φ的地点及该日太阳的赤纬有δ值时，确定在一天过程中由杆
的一点
投影所描绘的曲线。
第85题  日食和月食Solar and Lunar Eclipses
如果对于充分接近日食时间的两个瞬间太阳和月亮的赤经、赤纬以及其半径均
为已知
，确定日食的开始和结束，以及太阳表面被隐蔽部分的最大值。
第86题  恒星及会合运转周期Sidereal and Synodic Revolution Periods
确定已知恒星运转周期的两共面旋转射线的会合运转周期。
第87题  行星的顺向和逆向运动Progressive and Retrograde Motion of
Planets
行星什么时候从顺向转为逆向运动（或反过来，从逆向转为顺向运动）？
第88题  兰伯特慧星问题Lambert's Comet Prolem
借助焦半径及连接弧端点的弦，来表示慧星描绘抛物线轨道的一段弧所需的时
间。
第89题  与欧拉数有关的斯坦纳问题Steiner's Problem Concerning the Euler
Numbe
r
如果x为正变数，x取何值时，x的x次方根为最大？
第90题  法格乃诺关于高的基点的问题Fagnano's Altitude Base Point
Problem
在已知锐角三角形中，作周长最小的内接三角形。
第91题  费马对托里拆利提出的问题Fermat's Problem for Torricelli
试求一点，使它到已知三角形的三个顶点距离之和为最小。
第92题  逆风变换航向Tacking Under a Headwind
帆船如何能顶着北风以最快的速度向正北航行？
第93题  蜂巢（雷阿乌姆尔问题）The Honeybee Cell (Problem by Reaumur)
试采用由三个全等的菱形作成的顶盖来封闭一个正六棱柱，使所得的这一个立
体有预
定的容积，而其表面积为最小。
第94题  雷奇奥莫塔努斯的极大值问题Regiomontanus' Maximum Problem
在地球表面的什么部位，一根垂直的悬杆呈现最长？（即在什么部位，可见角
为最大
？）
第95题  金星的最大亮度The Maximum Brightness of Venus
在什么位置金星有最大亮度？
第96题  地球轨道内的慧星A Comet Inside the Earth's Orbit
慧星在地球的轨道内最多能停留多少天？
第97题  最短晨昏蒙影问题The Problem of the Shortest Twilight
在已知纬度的地方，一年之中的哪一天晨昏蒙影最短？
第98题  斯坦纳的椭圆问题Steiner's Ellipse Problem
在所有能外接（内切）于一个已知三角形的椭圆中，哪一个椭圆有最小（最大
）的面
积？
第99题  斯坦纳的圆问题Steiner's Circle Problem
在所有等周的（即有相等周长的）平面图形中，圆有最大的面积。
反之:在有相等面积的所有平面图形中，圆有最小的周长。
第100题  斯坦纳的球问题Steiner's Sphere Problem
在表面积相等的所有立体中，球具有最大体积。
在体积相等的所有立体中，球具有最小的表面。

		自动登录	找回密码
密码			注册

周恒（zhouheng1212 ）的窝！(粗体字文章别删)

浏览过的版块

真题小王子