博客园_hoodlum1980 [ 发发 ] 的技术博客

C/C++版实现（Base64, UrlEncode等）

2012-05-28T08:27:00Z

【原创性声明】：本文无实质性创新性内容，性质属于技术总结，内容是基于已有知识或定义的代码实现。文中的代码是我根据其他代码或者网络上的资料，写出的自己的版本。因为网络上的代码 C/C++ 版本的较少，或者本身不一定是最合适最容易使用的。所以我写的代码基本是以 C 语言和 C 字符串处理为主的，因此它也可以直接在 C++ 的项目中使用。

（1）Base64 编码。Base64 编码是把每 3 个字节转换成 4 个ascii 字符（根据字符表映射）。把文本编码后，对人来说难以直接阅读。结尾不足时可能有一到两个 "=" 字符的补齐。

//以下是 Base64.h 的内容:

size_t Base64_Decode(char *pDest, const char *pSrc, size_t srclen);
size_t Base64_Encode(char *pDest, const char *pSrc, size_t srclen);

//以下是 Base64.cpp 的内容:

BYTE Decode_GetByte(char c);
char Encode_GetChar(BYTE num);

//===================================
// Base64 解码
//===================================
BYTE Decode_GetByte(char c)
{
if(c == '+')
return 62;
else if(c == '/')
return 63;
else if(c <= '9')
return (BYTE)(c - '0' + 52);
else if(c == '=')
return 64;
else if(c <= 'Z')
return (BYTE)(c - 'A');
else if(c <= 'z')
return (BYTE)(c - 'a' + 26);
return 64;
}

//解码
size_t Base64_Decode(char *pDest, const char *pSrc, size_t srclen)
{
BYTE input[4];
size_t i, index = 0;
for(i = 0; i < srclen; i += 4)
{
//byte[0]
input[0] = Decode_GetByte(pSrc[i]);
input[1] = Decode_GetByte(pSrc[i + 1]);
pDest[index++] = (input[0] << 2) + (input[1] >> 4);

//byte[1]
if(pSrc[i + 2] != '=')
{
input[2] = Decode_GetByte(pSrc[i + 2]);
pDest[index++] = ((input[1] & 0x0f) << 4) + (input[2] >> 2);
}

//byte[2]
if(pSrc[i + 3] != '=')
{
input[3] = Decode_GetByte(pSrc[i + 3]);
pDest[index++] = ((input[2] & 0x03) << 6) + (input[3]);
}
}

//null-terminator
pDest[index] = 0;
return index;
}

//===================================
// Base64 编码
//===================================
char Encode_GetChar(BYTE num)
{
return
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"+/="[num];
}

//编码
size_t Base64_Encode(char *pDest, const char *pSrc, size_t srclen)
{
BYTE input[3], output[4];
size_t i, index_src = 0, index_dest = 0;
for(i = 0; i < srclen; i += 3)
{
//char [0]
input[0] = pSrc[index_src++];
output[0] = (BYTE)(input[0] >> 2);
pDest[index_dest++] = Encode_GetChar(output[0]);

//char [1]
if(index_src < srclen)
{
input[1] = pSrc[index_src++];
output[1] = (BYTE)(((input[0] & 0x03) << 4) + (input[1] >> 4));
pDest[index_dest++] = Encode_GetChar(output[1]);
}
else
{
output[1] = (BYTE)((input[0] & 0x03) << 4);
pDest[index_dest++] = Encode_GetChar(output[1]);
pDest[index_dest++] = '=';
pDest[index_dest++] = '=';
break;
}

//char [2]
if(index_src < srclen)
{
input[2] = pSrc[index_src++];
output[2] = (BYTE)(((input[1] & 0x0f) << 2) + (input[2] >> 6));
pDest[index_dest++] = Encode_GetChar(output[2]);
}
else
{
output[2] = (BYTE)((input[1] & 0x0f) << 2);
pDest[index_dest++] = Encode_GetChar(output[2]);
pDest[index_dest++] = '=';
break;
}

//char [3]
output[3] = (BYTE)(input[2] & 0x3f);
pDest[index_dest++] = Encode_GetChar(output[3]);
}
//null-terminator
pDest[index_dest] = 0;
return index_dest;
}

（2）UrlEncode （百分号编码）。方法是把输入的字符串先用 UTF-8 编码，然后把基本字符以外的字节用百分号加16进制的形式编码。UrlEncode 的最后一个参数含义是，编码结果中的16进制字符是否采用大写字母表示。

BOOL UrlEncode(const char* szSrc, char* pBuf, int cbBufLen, BOOL bUpperCase);
BOOL UrlDecode(const char* szSrc, char* pBuf, int cbBufLen);

//百分号编码
//http://zh.wikipedia.org/zh-cn/%E7%99%BE%E5%88%86%E5%8F%B7%E7%BC%96%E7%A0%81

BOOL UrlEncode(const char* szSrc, char* pBuf, int cbBufLen, BOOL bUpperCase)
{
if(szSrc == NULL || pBuf == NULL || cbBufLen <= 0)
return FALSE;

size_t len_ascii = strlen(szSrc);
if(len_ascii == 0)
{
pBuf[0] = 0;
return TRUE;
}

//先转换到UTF-8
char baseChar = bUpperCase ? 'A' : 'a';
int cchWideChar = MultiByteToWideChar(CP_ACP, 0, szSrc, len_ascii, NULL, 0);
LPWSTR pUnicode = (LPWSTR)malloc((cchWideChar + 1) * sizeof(WCHAR));
if(pUnicode == NULL)
return FALSE;
MultiByteToWideChar(CP_ACP, 0, szSrc, len_ascii, pUnicode, cchWideChar + 1);

int cbUTF8 = WideCharToMultiByte(CP_UTF8, 0, pUnicode, cchWideChar, NULL, 0, NULL, NULL);
LPSTR pUTF8 = (LPSTR)malloc((cbUTF8 + 1) * sizeof(CHAR));
if(pUTF8 == NULL)
{
free(pUnicode);
return FALSE;
}
WideCharToMultiByte(CP_UTF8, 0, pUnicode, cchWideChar, pUTF8, cbUTF8 + 1, NULL, NULL);
pUTF8[cbUTF8] = '\0';

unsigned char c;
int cbDest = 0; //累加
unsigned char *pSrc = (unsigned char*)pUTF8;
unsigned char *pDest = (unsigned char*)pBuf;
while(*pSrc && cbDest < cbBufLen - 1)
{
c = *pSrc;
if(isalpha(c) || isdigit(c) || c == '-' || c == '.' || c == '~')
{
*pDest = c;
++pDest;
++cbDest;
}
else if(c == ' ')
{
*pDest = '+';
++pDest;
++cbDest;
}
else
{
//检查缓冲区大小是否够用？
if(cbDest + 3 > cbBufLen - 1)
break;
pDest[0] = '%';
pDest[1] = (c >= 0xA0) ? ((c >> 4) - 10 + baseChar) : ((c >> 4) + '0');
pDest[2] = ((c & 0xF) >= 0xA)? ((c & 0xF) - 10 + baseChar) : ((c & 0xF) + '0');
pDest += 3;
cbDest += 3;
}
++pSrc;
}
//null-terminator
*pDest = '\0';
free(pUnicode);
free(pUTF8);
return TRUE;
}

//解码后是utf-8编码
BOOL UrlDecode(const char* szSrc, char* pBuf, int cbBufLen)
{
if(szSrc == NULL || pBuf == NULL || cbBufLen <= 0)
return FALSE;

size_t len_ascii = strlen(szSrc);
if(len_ascii == 0)
{
pBuf[0] = 0;
return TRUE;
}

char *pUTF8 = (char*)malloc(len_ascii + 1);
if(pUTF8 == NULL)
return FALSE;

int cbDest = 0; //累加
unsigned char *pSrc = (unsigned char*)szSrc;
unsigned char *pDest = (unsigned char*)pUTF8;
while(*pSrc)
{
if(*pSrc == '%')
{
*pDest = 0;
//高位
if(pSrc[1] >= 'A' && pSrc[1] <= 'F')
*pDest += (pSrc[1] - 'A' + 10) * 0x10;
else if(pSrc[1] >= 'a' && pSrc[1] <= 'f')
*pDest += (pSrc[1] - 'a' + 10) * 0x10;
else
*pDest += (pSrc[1] - '0') * 0x10;

//低位
if(pSrc[2] >= 'A' && pSrc[2] <= 'F')
*pDest += (pSrc[2] - 'A' + 10);
else if(pSrc[2] >= 'a' && pSrc[2] <= 'f')
*pDest += (pSrc[2] - 'a' + 10);
else
*pDest += (pSrc[2] - '0');

pSrc += 3;
}
else if(*pSrc == '+')
{
*pDest = ' ';
++pSrc;
}
else
{
*pDest = *pSrc;
++pSrc;
}
++pDest;
++cbDest;
}
//null-terminator
*pDest = '\0';
++cbDest;

int cchWideChar = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pUTF8, cbDest, NULL, 0);
LPWSTR pUnicode = (LPWSTR)malloc(cchWideChar * sizeof(WCHAR));
if(pUnicode == NULL)
{
free(pUTF8);
return FALSE;
}
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pUTF8, cbDest, pUnicode, cchWideChar);
WideCharToMultiByte(CP_ACP, 0, pUnicode, cchWideChar, pBuf, cbBufLen, NULL, NULL);
free(pUTF8);
free(pUnicode);
return TRUE;
}

（3）获取本机 IP 地址和网卡物理地址。可能有多个网络适配器，但这里只是给出第一个适配器的结果。根据网络资料，获取网卡物理地址有多种方法。已知 IP 地址获取其物理地址可以使用 SendARP 方法。但对于本机来说，可以直接用 GetAdaptersAddresses 更适合，其返回结果为链表（list）形式。这里对 IP 默认为 IPv4（4个字节），网卡物理地址通常为 6 个字节。

#include <Winsock2.h>
#include <IPHlpApi.h> //for GetAdaptersAddresses

//获取本机的IP地址
BOOL GetIPAddress(unsigned char* buffer)
{
int bRet;
char hostname[256];
WSADATA wsadata;
struct hostent *pHost;
struct in_addr *pAddr;
WORD dwVersionRequested = MAKEWORD( 2, 2 );

bRet= WSAStartup(dwVersionRequested, &wsadata);
bRet= gethostname(hostname, sizeof(hostname));
pHost = gethostbyname(hostname);

if(pHost != NULL && pHost->h_addr_list[0] != NULL)
{
pAddr = (struct in_addr*)(pHost->h_addr_list[0]);
buffer[0] = pAddr->s_net;
buffer[1] = pAddr->s_host;
buffer[2] = pAddr->s_lh;
buffer[3] = pAddr->s_impno;
bRet = TRUE;
}
else
{
//取不到IP地址，则赋值默认值 255.255.255.255
memset(buffer, 0xff, 4);
bRet = FALSE;
}
WSACleanup();
return bRet;
}

//参数pMacAddr应该是8个字节的数组
BOOL GetMacAddress(unsigned char* pMacAddr)
{
DWORD nRet;
//只查询物理地址
DWORD nFlags = GAA_FLAG_SKIP_UNICAST
| GAA_FLAG_SKIP_ANYCAST
| GAA_FLAG_SKIP_FRIENDLY_NAME
| GAA_FLAG_SKIP_MULTICAST
| GAA_FLAG_SKIP_DNS_SERVER;

ULONG bufLen = 1024;
PIP_ADAPTER_ADDRESSES pAdapterAddr = (PIP_ADAPTER_ADDRESSES)malloc(bufLen);
if(pAdapterAddr == NULL)
return FALSE;

//AF_INET: return only IPv4 addresses.
nRet = GetAdaptersAddresses(AF_INET, nFlags, NULL, pAdapterAddr, &bufLen);
if(nRet == ERROR_BUFFER_OVERFLOW)
{
pAdapterAddr = (PIP_ADAPTER_ADDRESSES)realloc(pAdapterAddr, bufLen);
if(pAdapterAddr == NULL)
return FALSE;

nRet = GetAdaptersAddresses(AF_INET, nFlags, NULL, pAdapterAddr, &bufLen);
}

if(nRet == ERROR_SUCCESS)
{
memcpy(pMacAddr, &pAdapterAddr->PhysicalAddress, pAdapterAddr->PhysicalAddressLength);
free(pAdapterAddr);
return TRUE;
}
else
{
//ff-ff-ff-ff-ff-ff: 表示获取失败（未知）
memset(pMacAddr, 0xff, 6);
free(pAdapterAddr);
return FALSE;
}
}

（4）使用 SMTP 发送邮件。本文是参考看雪论坛上某文章中的代码。如果发送中文，应该在传输时，指定文本使用的编码，以防止接收端解释成乱码。以下代码引用了（1）中的 Base64 编码。

#include <Winsock2.h>

typedef struct _SMTPINFO
{
char Server[32];
int Port;
char UserName[16];
char Password[16];
char From[32];
char To[32];
char Subject[32];
char Msg[256];
} SMTPINFO, *LPSMTPINFO;

BOOL Talk(SOCKET sockid, const char *szOkCode, char *pSend);
BOOL SendMail(const LPSMTPINFO pInfo);

//szOkCode: 是前一条命令成功时，预期的服务器的返回码
BOOL Talk(SOCKET sockid, const char *szOkCode, char *pSend)
{
const int buflen = 256;
char buf[buflen];

//接收返回信息
if (recv(sockid, buf, buflen, 0) == SOCKET_ERROR)
return FALSE;

if (strncmp(buf, szOkCode, strlen(szOkCode)) != 0)
return FALSE;

//发送命令
if (lstrlen(pSend) > 0)
{
WSABUF DataBuf;
DataBuf.len = lstrlen(pSend);
DataBuf.buf = pSend;

DWORD dwS;
if(WSASend(sockid, &DataBuf, 1, &dwS, 0, 0, 0))
return FALSE;
}
return TRUE;
}

BOOL SendMail(const LPSMTPINFO pInfo)
{
char buf[1024];
//准备网络连接
WSADATA wsadata;

if(WSAStartup(MAKEWORD(2, 2), &wsadata) != 0)
return FALSE;

//创建套接字
SOCKET sockid;
if ((sockid = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
{
WSACleanup();
return FALSE;
}

//得到smtp服务器ip
struct hostent *phostent = gethostbyname(pInfo->Server);
struct sockaddr_in addr;

CopyMemory(&addr.sin_addr.S_un.S_addr,
phostent->h_addr_list[0],
sizeof(addr.sin_addr.S_un.S_addr));

addr.sin_family = AF_INET;
addr.sin_port = htons(pInfo->Port);
ZeroMemory(&addr.sin_zero, 8);

//连接服务器
if(connect(sockid, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == SOCKET_ERROR)
goto STOP;

//EHLO 是对 HELO 的扩充命令。
strcpy(buf, "EHLO hoodlum1980\r\n");
if(!Talk(sockid, "220", buf))
goto STOP;

strcpy(buf, "AUTH LOGIN\r\n");
if(!Talk(sockid, "250", buf))
goto STOP;

size_t userlen = lstrlen(pInfo->UserName);
size_t passlen = lstrlen(pInfo->Password);
Base64_Encode(buf, pInfo->UserName, userlen);
strcat(buf, "\r\n");
if(!Talk(sockid, "334", buf))
goto STOP;

Base64_Encode(buf, pInfo->Password, passlen);
strcat(buf, "\r\n");
if (!Talk(sockid, "334", buf))
goto STOP;

//ZeroMemory(buf, buflen);
wsprintf(buf, "MAIL FROM:<%s>\r\n", pInfo->From);
if(!Talk(sockid, "235", buf))
goto STOP;

wsprintf(buf, "RCPT TO:<%s>\r\n", pInfo->To);
if(!Talk(sockid, "250", buf))
goto STOP;

strcpy(buf, "DATA\r\n");
if (!Talk(sockid, "250", buf))
goto STOP;

char szContent[512];
Base64_Encode(szContent, pInfo->Msg, strlen(pInfo->Msg));
wsprintf(buf,
"MIME-Version:1.0\r\nContent-Type:text/plain; charset=gb2312\r\n"
"Content-Transfer-Encoding:base64\r\nContent-Language:zh-cn\r\n"
"TO: %s\r\nFROM: %s\r\nSUBJECT: %s\r\n\r\n%s\r\n.",
pInfo->To, pInfo->From, pInfo->Subject, szContent);

if(Talk(sockid, "354", buf))
goto STOP;

strcpy(buf, "QUIT\r\n");
if(!Talk(sockid, "250", buf))
goto STOP;

strcpy(buf, "");
if(!Talk(sockid, "221", buf))
goto STOP;
else
{
closesocket(sockid);
WSACleanup();
return TRUE;
}

STOP:
closesocket(sockid);
WSACleanup();
return FALSE;
}

// 使用范例:
SMTPINFO info;
strcpy(info.Server,"smtp.***.com");
info.Port = 25;
strcpy(info.UserName,"XXXXX@***.com");
strcpy(info.Password,"*****");
strcpy(info.From, "XXXXX@***.com");
strcpy(info.To, "YYYYY@YYY.com");
strcpy(info.Subject, "邮件标题");
strcpy(info.Msg, "邮件内容。");
SendMail(&info);

（5）以 Post 形式发送 HTTP 请求。如果使用 C# 则可以使用 HttpRequest。由于是测试版本，以下代码在读取服务器响应时假设服务器的响应是短文本，因此没有判断服务器的响应是否已全部读取，并不是非常完善。在实际应用中应完善后使用。

#include <Wininet.h>
BOOL SendHttpPost()
{
HINTERNET hInternet = InternetOpen(_T("HttpPostTest"),
INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);

if(hInternet == NULL)
return FALSE;

HINTERNET hConnect = InternetConnect(hInternet,
_T("www.xxx.com"),
INTERNET_DEFAULT_HTTP_PORT,
NULL, //user
NULL, //password
INTERNET_SERVICE_HTTP, 0, 0);

if(hConnect == NULL)
{
InternetCloseHandle(hInternet);
return FALSE;
}

LPCTSTR szTypes[] = { _T("*/*"), NULL };
TCHAR szData[1024], szResponse[1024];
TCHAR szContent[1024], szTemp[128];

//全英文的ascii字符集是UTF-8的子集，所以下面的字符串也可以看着是 UTF-8 编码的。
_tcscpy(szContent, _T("user=xxx&password=xxx"));

DWORD dwBytesAvailable = 0, dwBytesRead = 0;

HINTERNET hRequest = HttpOpenRequest(hConnect,
_T("POST"),
_T("/xxx/xxx.aspx"),
NULL, //version: "HTTP/1.1"
_T("http://www.xxx.com/xxx/xxx.aspx"), //referer
szTypes, //types
INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_RELOAD, 0);

if(hRequest == NULL)
{
InternetCloseHandle(hConnect);
InternetCloseHandle(hInternet);
return FALSE;
}

BOOL bSuccess;

TCHAR headers[512];
_stprintf(headers, _T("Content-Length: %ld\r\n"), _tcslen(szContent));
_tcscat(headers,
_T("Content-Type: application/x-www-form-urlencoded\r\n")
_T("xxx: yyy\r\n")
);

bSuccess = HttpSendRequest(hRequest,
headers, //additional header
_tcslen(headers), //headersLength
szContent,
_tcslen(szContent));

TCHAR szBuffer[1024];
DWORD bufLen = sizeof(szBuffer);
DWORD dwIndex = 0;
if(bSuccess)
{
//查询服务器返回的headers信息，内含传输内容使用的编码。
HttpQueryInfo(hRequest, HTTP_QUERY_RAW_HEADERS_CRLF,
szBuffer,
&bufLen, &dwIndex);

InternetQueryDataAvailable(hRequest, &dwBytesAvailable, 0, 0);
bSuccess = InternetReadFile(hRequest, szResponse, sizeof(szResponse), &dwBytesRead);

int count = MultiByteToWideChar(CP_UTF8, 0, szResponse, dwBytesRead, szDataUnicode, sizeof(szDataUnicode)/sizeof(szDataUnicode[0]));
count = WideCharToMultiByte(CP_ACP, 0, szDataUnicode, count, szData, sizeof(szData)/sizeof(szData[0]), NULL, NULL);
szData[count] = '\0';
}

InternetCloseHandle(hRequest);
InternetCloseHandle(hConnect);
InternetCloseHandle(hInternet);
return bSuccess;
}

以下是 java 版本的类似代码：

public String SendRequest()
{
//发送post请求获取签名
String postData = "user=%s&password=%s";
byte[] postBytes = postData.getBytes();
URL url = new URL("http://www.xxx.com/xxx/xxx.aspx");
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
connection.setDoOutput(true);
connection.setDoInput(true);
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Length", String.valueOf(postBytes.length));
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("xxx", "yyy");
connection.setUseCaches(false);
connection.connect();

DataOutputStream out = new DataOutputStream(connection.getOutputStream());
out.write(postBytes);
out.flush();
out.close();

StringBuffer buf = new StringBuffer(960);
int responseCode = connection.getResponseCode();
if(responseCode == 200)
{
//获取服务器返回的数据
InputStream stream = connection.getInputStream();
BufferedReader bufReader = new BufferedReader(new InputStreamReader(stream));
String line = "";
while((line = bufReader.readLine()) != null)
buf.append(line);
}
return buf.toString();
}

【参考资料】：

本文链接

ZOL1871 Steps

2012-05-28T03:30:00Z

ZOL 1871: Steps

地址：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=871

题意：假设在一条直线上标记着数字刻度。每一步的步长不能为负数，且和前一个步长的关系必须是相等，或大于或小于1。第一步和最后一步的步长必须是1。则从 x 到 y 的最小步数是多少。

可以用数学语言重新描述题目如下：给出无符号整数 d ( = y-x ) ，可分解为满足下列条件的 n 个正整数的和，求 n 的最小值:

d = ∑ Si ; (i = 1 ... n)

且满足：

S1 = Sn = 1;

| S(i + 1) - Si | ≤ 1;

分析：根据题目要求，理想条件下，为了达到最小步数，步长变化应该是从1，2，3 ... 一直增加到最大值 M，然后逐渐减小到1：

distance = y - x ;

distance = 1 + 2 + 3 + ... + M + ... + 3 + 2 + 1 = M^2;

steps = 2 * M - 1; (步数)

因此如果距离正好是一个平方数（M 的平方），则步数一定是（2M-1），其中 M 为最大步长。当距离不是平方数时，假设介于 M^2 和 (M+1)^2 之间，则

distance = M^2 + remain; (0 < remain <= 2M )

remain 是平方数后的尾数，如果remain 小于等于 M，则我们只需要把一个 remain 的步长插入到前面的序列中即可。如果 remain 大于 M，则一步是不够的，我们至少需要插入两步，M 和 remain - M（当然，也可以是 remain/2 和 remain - remain/2）。因为我们不能插入大于 M 的步长，否则最终累加的和会达到下一个平方数（（M+1）的平方）。

因此根据上述分析，代码如下（代码中为了可读性，M 用 maxStep 表示）：

#include <stdio.h>
#include <math.h>
int main(int argc, char* argv[])
{
unsigned int x = 0, y = 0;
unsigned int distance, maxStep, remain, steps;
while(scanf("%lu %lu", &x, &y) != EOF)
{
distance = y - x;
if(distance == 0)
{
printf("0\n");
continue;
}
maxStep = (unsigned int)sqrt(distance);
remain = distance - maxStep * maxStep;

steps = maxStep * 2 - 1;
if(remain > 0)
{
if(remain <= maxStep)
steps++;
else
steps += 2;
}
printf("%lu\n", steps);
}
return 0;
}

本文链接

[发布] 电量监视+自动关机工具

2012-02-15T17:06:00Z

这是一个主要用于在桌面上显示笔记本电池剩余电量的 windows 程序，同时也具有自动关机功能（自动关机功能我自己尚未实际测试过）。因此第一个功能，监视电池的剩余电量的百分比，这个主要对使用充电电池的笔记本电脑有用，台式机不能获取到电池数据（显示NA），所以对台式机没什么意义。因此对台式机来说，它仅相当于一个自动关机的应用程序。

开发语言：C++；开发环境：VS2005；

该程序的前身来源于几年前我用 C# 开发的类似程序，现在的程序在绘制和效果上基本相同，只是舍弃了 C# 程序对 .net framework 平台的依赖，以及调用 Windows API 时那些不优雅的平台调用（Platform Invoke）代码。

可以让提示窗口自动依附到当前活动窗口的标题栏（靠右侧），为完成这个功能，我需要知道当前活动窗口，并且随着它移动而移动。效果如下图所示。

放大到 400% 后的显示效果（左侧小图标表示交流电源在线）如下，可见文本被进度割裂成两部分，其前景和背景色为交替状态：

【注意：如果程序被 360 木马防火墙拦截】

为了完成依附到窗口标题栏的功能，我安装了一个全局的 CBT Hook （功能位于 CBT.dll ），用于获知系统中的窗口被激活，窗口被移动，最大最小化，关闭等事件。由于用了 SetWindowsHookEx 等敏感的 API 函数，因此可能会如 360 木马防火墙拦截。如果你安装了 360 系列工具，请在运行之前，在360木马防火墙中把程序的 PowerMon.EXE 和 CBT.DLL 文件加入信任列表，或者在防护状态中关闭系统防御中的“文件系统防护”。

对系统通知区的图标点击右键，可以弹出上下文菜单，选择“自动关机”菜单，则弹出自动关机的设置窗口如下。可以设置在一段时间或者某个时刻自动关机。自动关机的计时单位精确到分钟。点击确定后，窗口由电池轮廓形状变成倒计时进度条，同时左侧会显示一个“电源”小图标（屏幕右下角通知图标也会切换成一个红色的关机图标），表示进入自动关机状态。如果要取消自动关机，只需再次点击通知图标的上下文菜单，选择“取消自动关机”即可。在倒计时结束后，仍然会弹出一个对话框请求用户确认自动关机，该对话框停留 20 秒钟时间给用户考虑，用户可以在考虑时间内取消自动关机。

通过通知图标的上下文菜单，选择“选项”，如下图所示。关于设置功能，简单介绍如下：

（1）刷新频率：程序查询电池剩余电量的频率，单位是秒。

（2）不透明度：窗口的 Alpha 值，范围从 0 ~ 255。

（3）依附到当前窗口标题栏：如果不勾选，则程序窗口在屏幕上的位置不会发生变化，这时可以用鼠标进行拖动。勾选以后，窗口自动依附到当前窗口的标题栏靠右侧位置。

（4）忽略自绘窗口：由于程序使用的是系统配色进行绘制，因此依附到系统统一外观的标准标题栏上视觉效果最好。但是有很多窗口不是标准窗口，这些窗口可能采用了例如 DirectUI 技术来呈现自定义的个性外观，达到更美化的效果，例如 QQ 等客户端。因此依附到这些窗口的右上角时，两者的配色不能保证配色非常协调，因此程序默认，将不会依附到自绘窗口上。

（5）开机自动运行：如果勾选，将在注册表的下列位置创建 “powermon” 值，用于自动启动。取消打钩时删除该值。

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run

【已知的一些问题】

（1）依附到窗口标题栏时，某些时候依附的位置不正确。目前已发现的包括窗口类为“CabinetWClass”的窗口，如 windows 资源管理器等。另外，有些时候某些窗口被激活时，电量提示窗未能依附到活动窗口。

（2）被依附的窗口关闭，最小化时，有时电量提示窗停留在原来的位置，在屏幕上呈现“悬空”状态。

【可执行文件下载链接】

http://files.cnblogs.com/hoodlum1980/PowerMon.rar

【BUG修正】

（1）[H] 修复 CBTProc 中处理结束时没有调用 CallNextHookEx 的 bug，该 bug 可能引发输入法切换失效。

（2）[M] 修复更新进度条进度时，刷新矩形没有涵盖右下方向的行列像素问题，该 bug 导致显示问题。2012年2月20日。

本文链接

ZOL1096 （Subway）和 ZOL1086（Octal Fractions）

2011-12-19T20:22:00Z

（一）ZOL 1096：Subway

链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1096
题意：给出下列参数（所有参数均为小于等于1000的正整数），求地铁列车从一个站点到下一个站点之间的最短时间（精确到 0.1 秒）。

d - 地铁站之间的距离（米）;
m - 列车的最大速度（米 / 秒）;
a1 - 最大加速度（绝对值）（米 / 秒^2);
j1 - 最大 jerk （绝对值）（米 / 秒^3).

备注：最后一个条件中的 Jerk 就是加速度对时间的导数：d/dt (a); 相当于列车所受的合力对时间的变化率，该限制条件用于防止车厢内站立的乘客摔倒。
分析：此题的重点在于考察数学和物理基础，编程本身倒不重要。对这道题目，要求求列车运行的最短时间，显然，列车应该尽可能快的加速到最大速度，然后尽可能快的减速到停止。这个结论是很显然的。由于这是OnlineJudge 题目，所以我们也不必此结论做严格的数学证明。（如果不是这样，即列车没有尽可能快的加速，那么其 v- t 曲线就会位于最佳曲线的下方，为了保证面积相等，则其时间一定要超过最佳曲线）
可以绘制出列车运行的速度曲线 v = v( t )，根据物理知识，上诉条件相当于下列表达式：

∫ v dt = d; (列车走过的距离，即 v( t ) 曲线和横轴围成的面积)
v ≤ m;
| d(v)/dt | ≤ a1;
| d^2(v)/dt^2 | ≤ j1;

根据前面的假设，v(t) 在起始阶段一定是以最大的 j1 在加速。因此：

（1）全力加速： v(t) = 1/2 * j1 * t^2; 曲线 v 为一段抛物线。设持续时间为 t1；加速度 a = j1 * t;
（2）当到达t1时，假设此时达到了最大加速度 a1。然后保持加速度为 a1 不变，进入匀加速直线运动阶段，此时曲线 v 为斜率为 a1 的直线。加速度 a = a1；设持续时间为 t3；
（3）在此速度上继续加速，但尽全力降低加速速度，直到最大速度 m。曲线 v 依然是抛物线，只是开口方向相反。持续时间依然为 t1；加速度 a = - j1 * ( t - t1 - t3);
（4）已最大速度 m 进入匀速直线运动。曲线 v 是水平线段，加速度 a = 0；设该段的持续时间为 t2；
（5）全力减速，抛物线，和（3）对称，持续时间为 t1。
（6）以最大减速速度 -a1 进行匀减速直线运动，斜率为 -a1 的直线线段，和（2）对称，持续时间为 t3。
（7）继续全力减速，直到停止在下一个站点，和（1）对称，持续时间为 t1。

注意上诉过程包含了 4 个含有参数 j1 的抛物线片段，先解释下 j1 的物理含义，假设列车运行在光滑轨道上，只受到一个牵引力，则在这些时间段上，牵引力变化的最快，加速度变化的最快（乘客最容易因为惯性发生摇晃）。物理量 Jerk 表示的是加速度变化的速度，根据牛顿第二定律，也就是物体所受合力的变化速度。举个例子，列车如果正在用最大牵引力进行全力加速，这时候乘客倾向于向后倾倒，乘客需要用很大力气紧紧抓住车厢内的扶手，为了让乘客保持稳定，这个牵引力不应该猛然撤去，而应该逐渐减小（相当于上面的曲线片段3），如果在全力加速时一瞬间撤去牵引力，乘客就会感觉很不稳定很不舒服（上海地铁中这种现象很常见，乘客应该有所体会，在列车加速时非常不稳，也就是列车受力的变化速度太快，即 j 太大了，很显然我想上海地铁应该是达不到本题目中要求的这么理想化的）。同理，如果列车在静止状态或者匀速状态，牵引力也应该逐渐加大，而不是一瞬间加到最大（这会对列车产生“猛推”效果，造成乘客在车厢内摇晃）。
最大加速度 a1 的物理含义表征的是牵引或者制动时的最大合力，不考虑刹车的话也就相当于发动机的最大输出牵引力（注：不是功率）。
上诉过程的速度 v（t）曲线如下图所示（注意：图形中的背景色表示的仅是片段的物理运动性质，但不代表相互衔接的曲线一定来自相同函数，下面的 case 图与此相同）：

很显然，曲线是关于垂直中心线轴对称的。求上诉曲线的积分即和 t 轴围成的面积很容易，抛物线由四个片段组成，它们能拼合成两个面积为（m * t1）的矩形。斜率为 ±a1 的匀加速直线运动部分，是两个梯形，它们也能拼合成一个面积为（m * t3）的矩形。最后中间的匀速直线运动部分，是一个面积为（m * t2）的矩形。因此，对于上诉过程有：

d = ∫ v dt = m * ( t1 * 2 + t3 + t2 ); // 两个站点之间的距离
min ( t ) = t1 * 4 + t3 * 2 + t2; // 最短运行时间

注意：这是一种运动种类最多的“理想状况”，即距离 d 足够长，使得可以加速到最大速度 m； a1 要足够小，使得可以“割断”抛物线，出现斜线部分。实际上由于四个参数的值是任意给出的整数，这些参数可能只有一部分真正的对结果产生了限制作用，因此我们必须考虑下面的四种实际 case，如下图所示：

（1）case 1：受到距离 d 的限制，不受 m，a1 的限制。曲线只有四个抛物线片段。

根据：∫ v dt = max(v) * t1 * 2 = (j1 * t1^2) * t1 * 2 = d; （受到距离 d 的限制）
结果：min(t) = t1 * 4 = [ (d / 2 j1) ^ (1/3) ] * 4;
条件1：max(v) = j1 * t1^2 ≤ m; （不会受到最大速度 m 的限制）
条件2：max(a) = j1 * t1 ≤ a1; （不会受到最大加速度 a1 的限制）
　　（2）case 2：受到最大速度 m 的限制，即能加速到最大速度m（此种情况可认为不受距离 d 的限制，当然也可以说 m 太小），同时也不受 a1 的限制。曲线由四个抛物线片段加一段水平线段组成。

根据：1/2 * j * (t1 ^ 2) = m / 2; （受到最大速度 m 的限制）
求出：t1 = sqrt (m / j1); 以及 t2 = (d - m * t1 * 2)/m;
结果：min(t) = t1 * 4 + t2;
条件1：m * t1 * 2 ≤ d; （不会受到距离 d 的限制）
条件2：max(a) = j1 * t1 ≤ a1; （不会受到最大加速度 a1 的限制）

　　（3）case 3：受到最大加速度 a1 的限制，同时受到距离 d 的限制，所以不能加速到最大速度 m （即不会受到最大速度 m 的限制）。曲线由四个抛物线片段加上两段斜率绝对值为 a1 的倾斜线段组成。则由下列方程：

j1 * t1 = a1; （受到 a1 的限制）
max(v) = j1 * (t1^2) + a * t3;
d = max(v) * (t1 * 2 + t3);
结果：min(t) = t1 * 4 + t3 * 2;
条件1：max(v) ≤ m; （不受到最大速度 m 的限制）
条件2：t3 ≥ 0; （关于 t3 的负数解在后面讨论）

整理上面的方程式，我们得到一个关于 t3 的一元二次方程如下：
a1 t3^2 + [ 3 (a1^2) / j1 ] t3 + [ 2 ( a1^3 ) / ( j1^2 ) - d ] = 0;

可以根据一元二次方程的求根公式求出上面的 t3，解有两个，显然应该舍弃其中为负数的根，取正数根。
【注意】这里 t3 的被舍弃的负数解的数学和物理意义是什么？在给出代码后将继续讨论这个问题。

（4）case 4：就是前面分析过的所有运动都包括。受到 a1 的限制因此有斜线段部分，受到 m 的限制因此有水平线段部分。但不受到距离 d 的限制（即能加速到最大速度）。有：

j1 * t1 = a1; （受到最大加速度 a1 的限制）
m = j1 * (t1^2) + a * t3; （受到最大速度 m 的限制）
t2 = ( d - m * t1 * 2 - m * t3 ) / m; （不受到距离 d 的限制）
结果：min(t) = t1 * 4 + t3 * 2 + t2;

case 4 需要满足的条件实际上不需要列出，因为如果前面的case都不满足条件，则一定会落入case 4。这里为了完备，我依然给出case 4需要满足的条件：
条件1：max ( v ) / 2 = 1/2 * j1 * (t1^2) ≤ m/2; （为了能达到最大加速度a1，要有足够的加速空间，因此 m 必须足够大）。
条件2：m * ( t1*2 + t3 ) ≤ d; （为了达到最大速度，必须有足够长的距离，因此 d 必须足够大）。

/***********************************************************/

好了，现在我们已经考虑了四种 case，有没有任何遗漏的 case （要注意如果有就意味着 WA！）？考虑下斜线段出现的条件是不是一定要达到最大加速度 a1？是的，因为如果没有达到最大加速度 a1 就进入某个斜率小于 a1 的斜线段，那么如果我们继续走抛物线（因为这时速度上还有继续加速的空间，而加速度还没有上升到最大值 a1，所以抛物线是可继续的），就能更快达到最大速度，因此最终使用的时间一定会更短（假设在某点有两条岔路，一条是高速公路，一条是坑坑洼洼的土路，它们都是可选的，你选哪一条？）！
总结：注意上面的所有条件中都有等于号，等于即表示 case 和 case 之间的临界点。上面的 case 的排序是根据编码实现比较方便的情况，从 case 1 可以比较容易演化到后续的 case（但其他 case 之间的演化，参数之间的相互作用要稍复杂一些），例如：处于 case1 时，如果把 m 水平线向下移动（减小 m），就会从 case1 转入 case2；如果把表示斜率的那条射线向水平方向的 t 轴方向转动（减小 a1 ），就会从 case1 转入 case3；或者把距离拉长（增大 d），则曲线将向上浮动，最大速度将增大，如果先遇到 m 限制，则从 case1 转入 case2，如果先遇到 a1 限制，则从 case1 转入 case3。如果前面的case不能符合条件，则最终一定会落入位于后面的case（这里我依然是基于我个人的编程经验和直观印象，最好应该更严谨一点）。case1是最特殊也是最简单的情况。最后的结果是一个四元函数（超过了比较容易直观理解的维度）：

min ( t ) = f (d, m, a1, j1);

可以想象根据上面的求解过程，它类似分段函数，在不同范围内是关于不同变量的函数。
最后我们对上诉 case 给出下列表格：

CASES 起到限制作用的参数运动组成最短时间
case 1 d 抛物线 t14
case 2 m 抛物线, 水平线(匀速) t14 + t2
case 3 d, a1 抛物线, 斜线(匀加速) t14 + t32
case 4 m, a1 抛物线, 斜线(匀加速), 水平线(匀速) t14 + t32 + t2

注意参数 j1 的用法和其他三个参数不同，它是直接应用到抛物线函数中的参数，是唯一被直接使用的参数（其他三个参数主要起到限制作用），所有 case 都会包含四个抛物线片段，所以上表中 j1 不会在“起到限制作用的参数”中列出。前面已经提到过，这是基于直观印象的结果，我们尚未（也并无必要）从数学上去证明这一点。
最后给出该题目的代码，实际上就是从上诉推导过程直接翻译过来，代码本身没有任何难度。

#include <stdio.h>
#include <math.h>

double GetMinTime(int d, int m, int a, int j)
{
double t1, t2, t3;

/* case 1: 受限于路程d。全程 O(t^2) 加速，只有抛物线的四个片段组成 /
t1 = pow(d0.5/j, 1.0/3.0);
if(j * t1 <= a && j * t1 * t1 <= m)
{
return t1 * 4;
}

/* case 2: case 1 的基础加上 v = m 的匀速运动。可以加速到最大速度m。/
t1 = sqrt(m1.0/j);
if(jt1 <= a && mt12 <= d)
{
t2 = d1.0/m - t12;
return t1 4 + t2;
}

/* case 3: 受限于最大加速度a。全称加速，不能加速到最大速度m /
/ 含有两段匀加速直线运动 O(t^2) and O(t) /
t1 = a1.0/j;
double aa = a;
double bb = aa3.0/j;
double cc = aaa2.0/(jj) - d;

t3 = (sqrt(bbbb - 4aacc) - bb)/(aa2);
double vmax = aa1.0/j + at3;
/ double s = vmax * (t1 * 2 + t3); /

if(t3 >= 0 && vmax <= m)
{
return t1 4 + t3 * 2;
}

/* case 4: 受限于最大速度m。中途匀速 /
t3 = m1.0/a - a1.0/j;
t2 = d1.0/m - (t12 + t3);
/ 此处必定满足：t1>=0, t2>=0, t3>=0 /
return t1 4 + t3 * 2 + t2;
}

int main(int argc, char* argv[])
{
double time;
int d, m, a, j;
while(scanf("%d %d %d %d", &d, &m, &a, &j) != EOF)
{
time = GetMinTime(d, m, a, j);
time = ((int)(time10 + 0.5)) 0.1; /* 对 0.1 以下的小数四舍五入 /
printf("%.01f\n", time);
}
return 0;
}

最后，这道题目的序号是1096，位于第一个 problem sets 内，可以说排序是非常靠前的，但 AC 数量目前只有 172 ，提交数量只有 558，可见这些数据还是反映了其“难度”，但是难度主要在于数学和物理知识基础上，和编程本身，算法等技巧上倒是没有太大关系。

【补充讨论】case3 中 t3 的负数解的数学意义。
在case 3中，求解 t3 的一元二次方程现在提出一个问题，为什么出现负数解，其数学和物理意义是什么，该方程是由 d，a1，j1 （不受到 m 的限制）组成的表达式为系数。由于方程的前两个系数必定为正数，因此其中的一个根一定是负数（如果存在解）。那么为什么存在负数解，它的意义是什么？

首先，在数学上，列出该方程的前提是，t3 >=0，最终列车经过抛物线和匀加速直线运动，到达下一个站点。我们对 d，a1，j1 代入具体数值，构造出一正一负的两个解。参数是：
a1 = 2; j1 = 2; d = 12;
这时候抛物线部分是标准抛物线 y = x^2;
可以解出 t1 = 1;
关于 t3 的方程是 t3^2 + 3 t3 - 4 = (t3 - 1) (t3 + 4) = 0; 因此 t3 = 1 或者 t3 = -4；
可以在数学上绘制出 t3 的这两个解的情况的 v-t 曲线，如下图所示：

图中红色线条部分就是 t3 = -4 的情况。图中的红色箭头表示的是积分方向。因此可见上面的曲线积分中，抛物线（t1）和斜线段（t3）之间由于积分方向不同，存在一些相互抵销作用。从而最终能积到面积 d。这是 t3 的负数解在数学上的含义。但是在物理意义上这样是很难理解的，因为从抛物线片段后，出现了“负时间”，即时间倒流，最终列车停下来时是出发前 4 秒中。因为向着 t 轴负方向，所以 a = dv/dt 并未发生突变。而这种情况在物理意义上比较难以理解。
为了更好理解，换一种方式，把上图中的斜线段部分全部向 t 的正方向映射（由于做了镜面映射，dx = -dx' 所以对应线段上的积分方向同时会被改变），从而上图会演化成下面的图形：

在上图中，如果把 t3 视作正数，则意味着加速度在每个衔接点处发生突变（即列车受到无穷大作用力，或者列车质量忽略不计，可看作没有质量没有惯性的质点），显然这也是超现实的。如果不考虑图中的积分方向，则曲线形成的面积显然比 d 大，因此图中标示出了积分方向，实际上两部分是相互抵销作用（斜线部分的积分是 24，抛物线部分的积分是 -12，因此最终两者累加结果是 d = 12）。
尽管 t3 的负数解在物理上没有令人满意的含义，但这就是满足 v 的积分 = d 的数学上的另一种可能情况。

（二）ZOL 1086： Octal Factions

链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1086
题意：给出一个八进制的小数，转换为 10 进制小数。输出格式是：0.d1d2d3 ... dk [8] = 0.D1D2D3 ... Dm [10]；
例如对八进制小数0.75，转换为10进制，输出格式：0.75 [8] = 0.953125 [10]。
分析：整数的进制转换的方法非常简单，而这道题目是小数进制转换，把 8 进制转换到 10 进制的直接方法是：
Decimal = d1 * 8^(-1) + d2 * 8^(-2) + ... + dk * 8 ^(-k)
例如对 0.75 （8进制），十进制小数 = 7 / 8 + 5 / 64 = 0.963125;

但是仅仅从题目给出的样例输出来看，语言本身的内置数据类型 double 的精度可能已经不能满足要求了，因此这道题目看起来还是类似大数运算一类的题目，需要借助一个数组来存储数位。但是如果用上面的直接转换方法从 8 进制转换到 10 进制，用数组的方法，在编码实现上是很不方便的。所以考虑以 2 进制小数作为中介，即先把 8 进制转换到 2 进制小数，再转换到 10 进制。后面我们就能看到，这样我们就能很方便的利用数组来保存和给出具有任意精度（取决于数组大小，当然，如果追求更高精度也会引入少许时间和空间的代价）的结果。

把 8 进制小数转换到 2 进制小数的方法非常简单，只需要把8进制小数的每一位用三位二进制数表示即可，例如 0.75 [8] = 0.111 101 [2]; 设 d1 = (b1 b2 b3) [2], d2 = (b4 b5 b6) [2]：
则对应的：0.d1 d2 d3 ... dk [8] = 0.b1 b2 b3 b4 b5 b6 ... b(3k) b(3k+1) b(3k+2) [2]
这是显然的，因为：d1 = b1 * 4 + b2 * 2 + b3，...
所以 d1 * 8^(-1) + d2 * 8^(-2) + ... + dk * 8 ^(-k) = (b14 + b22 + b3) / 8 + ... = b1/2 + b2/4 + b3/8 + ... = 0.b1b2b3b4...[2];

再把这个二进制小数转换到 10 进制。为了精度需要，这里我引入一个数组：
unsigned char Dec[K]; // K 是一个常数，表征精度
这个数组的意义是，如果10进制小数是 0.D1D2D3 ... Dm [10]，则 Dec[i] = D(i+1); 最终的10进制小数将是这样：
0. Dec[0] Dec[1] Dec[2] ...

打印时只需要在前面加上“0.”前缀，然后从 0 索引开始依次输出其元素即可。

这里必须注意到二进制小数的小数点后第 k 位的基数 (0.5 ^ k) 的一个很重要的特征，即 (0.5 ^ k) 的小数点后的位数个数是 k（之后将全部是 0）。例如：
0.5，0.25，0.125，0.0625，...

注意这个序列，b[ i + 1 ] = b[ i ] / 2; 由于末尾数永远是5，因此每一次除以 2 都会导致递增一位。因此引入另一个辅助存储空间，用于存储 2 进制小数的从小数点后第 1 位到第 K 位的基数（K 取决于需要的精度），显然这是一个矩阵，例如如果取 K = 6，则定义矩阵 A ：
unsigned char A[6][8];
经过初始化计算后，A 的内容如下：
5, 0, 0, 0, 0, 0, 0, 0,    // A[0]: 0.5
2, 5, 0, 0, 0, 0, 0, 0,    // A[1]: 0.25
1, 2, 5, 0, 0, 0, 0, 0,    // A[2]: 0.125
0, 6, 2, 5, 0, 0, 0, 0,    // A[3]: 0.0625
0, 3, 1, 2, 5, 0, 0, 0,    // A[4]: 0.03125
0, 1, 5, 6, 2, 5, 0, 0,    // A[5]: 0.015625

它的右上角元素全是0，应该算是一个下三角矩阵。其意义是 A[k] 是二进制小数第 k+1 位的基数，即 A[k] = 1/2^(k+1); 小数位长度是 Length (A[k]) = k+1;
这个矩阵类似做菜时事先准备的材料，在求解之前先计算好备用。
求解过程如下，首先把结果 Dec 数组全部清零，然后对 8 进制的小数的每一位小数，当作三位二进制数，如果对应的位为 1，就把该位的基数（ A[k] ）逐位累加到结果数组 Dec。最后我们在从后（远离小数点的那一侧）向前处理进位即可，这个过程称为规整，即大数算法中最后的步骤。

代码如下：

#include <stdio.h>
#include <string.h>

/* 计算结果 0.N[0] N[1] ... /
unsigned char Dec[48];

unsigned char A[48][56]; / A[k] = 1/( 2^(k+1) ) /

/ A[k] 's digit length = (k + 1) /

void Init()
{
int i, j, carry = 0;
A[0][0] = 5;
for(i = 1; i < 48; i++)
{
for(j = 0; j < (i+1); j++)
{
A[i][j] = (A[i-1][j] + carry) / 2;
carry = (A[i-1][j] & 1) 10;
}
}
}

/* 返回 digit 数位长度/
int Convert(char pOctNum)
{
/* 位索引 /
int testNum[] = { 4, 2, 1 };
int index = 0, length = 0;
int i, j, carry, digit;
char p = pOctNum + 2; /* Ignore "0." /

memset(Dec, 0, sizeof(Dec));
while(p)
{
digit = p - '0';
for(j = 0; j < 3; j++)
{
if(digit & testNum[j])
{
length = index3 + j + 1;
for(i = 0; i < length; i++)
Dec[i] += A[index3 + j][i];
}
}
++p;
++index;
}

/ 归整数位 /
for(i = length; i > 0; --i)
{
if(Dec[i] > 9)
{
carry = Dec[i]/10;
Dec[i-1] += carry;
Dec[i] = Dec[i] - carry 10;
}
}
return length;
}

int main(int argc, char* argv[])
{
int length, i;
char line[256];
Init();
while(gets(line) != NULL && line[0] != 0)
{
length = Convert(line);
printf("%s [8] = 0.", line);
for(i = 0; i < length; i++)
{
printf("%d", Dec[i]);
}
printf(" [10]\n");
}
return 0;
}

总结：
（1）上面的方法，引入的辅助数据是二进制小数的基数，这是因为二进制小数在数位上只有 0 ，1 两种可能，这样实际上就是提供的结果就是，我们是否累加某一个基数到结果中。考虑如果我们用辅助空间存储的直接就是 8 进制小数的基础，则首先，我们要准备这样的基数的代码实现就比较麻烦（准备过程同样是大数除以一个小整数的大数运算！！）。另一点很不便的就是每个基数的小数的位长度和所在位之间没有直接的函数关系（而2进制小数的基数具有这样一个直接关系），我们还需要用对应的某一位上的数字去乘以这个基数再进行累加（而二进制小数的基数直接累加即可）。当然主要的麻烦在于第一点。第二点本来就位于大数算法中的过程之中，所以倒不显得困难。

（2）思考上面的累加过程然后规整数位，有一个累加进位的过程，但该过程是不可能使进位持续到整数部分的，即，假设一个小数的进制为 k ( k >= 2 )，则如果小数点后每一位都是最大数字（k - 1），则这个小数在无限长循环下等于1。即：
1 = 0.99999...[10] = 0.11111...[2] = 0.77777...[8];

该小数为数列的求和：
f (n) = (k-1) * (k^-1 + k^-2 + ... k ^ -n) =   (1 - k^-n) ;

n 趋向无穷大时，lim f(n) = 1;

（3）题目中并没有明确指明或者暗示我们最终结果的精度，我们如果想要得到更高精度可以把数组取得更大，同时会增加内存需求。因此 K 的取值需要逐渐调整然后提交去“试验”。最初我取 K 值为 256，空间需求略大。最终代码中取 K = 48，结果就内存就已经降低到了ZOL上 C 语言的典型内存需求（120 KB左右）。

【注】本文插图由 GrafEq 和 Photoshop CS 共同绘制。
本文链接

有关进程空间，全局变量，静态变量

2011-11-23T15:13:00Z

【创新性声明】本文没有本质上的创新性内容。属于一些实验和总结，有少量主观推测成分（有待进一步证实）。写这一类文章是非常危险的，因为有很多东西可能是我们不了解和比较模糊的，这很可能会出现错误的主观臆测，不仅仅是令明真相者贻笑大方的问题，更可怕的在于传播“错误”，这是我最为诚惶诚恐的一点。比如，我之前见到我指点过他的sun先生对于Photoshop中置换滤镜中的他的那些主观错误结论已经传遍网络，尽管可能没有太多人能关注到这个层面，但是我还是为这些错误的观点在网络上比比皆是而深感遗憾。正因为此，这篇文章我受限于个人水平，也不能100%确保自己不犯下认知性错误，因此此本（1）需要更专业的人的监督和意见，（2）可能随着我自己认知的变化而进行修订和变更。

最近在一些回复中提到了一些静态变量，线程安全性，递归函数调用的问题。尽管大概情况我已经清楚，但感觉自己在某些细节方面还稍显模糊，因此在这个问题应该从底层上做一个重新的总结，把一些比较容易产生模糊的问题总结下。

（1）全局变量，和静态变量位于进程空间什么位置。

为此，我用 VC6 新建了一个 Windows Console Application 。并输入代码如下：

#include <stdio.h>
#include <stdlib.h>
//#include <process.h>
#include <tchar.h>
#include <windows.h>

typedef HANDLE (WINAPI *FuncPtr)(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);

class TestClass
{
public:
TestClass()
{
printf("TestClass's constructor.\n");
}
~TestClass()
{
printf("TestClass's destructor.\n");
}
};

TestClass g_class;

int g_Temp1 = 0x11223344;
int g_Temp2;
int g_Array[4];
int g_Temp3;

//The default size for the reserved and initially committed stack memory
//is specified in the executable file header.
DWORD WINAPI threadProc(LPVOID lpParameter)
{
int a = 0;
int threadIndex = (int)lpParameter;
printf("%p: auto variable on new thread's stack (thread: %d)\n", &a, threadIndex);
return 0;
}

int main(int argc, char* argv[])
{
static int nStatic1 = 0x12345678;
static int nStatic2 = 0x00abcdef;
static int nStatic3;

int a = g_Temp1 & 0xffff;
char* pConstData = "Hello World";

//pConstData[1] = 0; //内存访问冲突（不可写）

char* pHeap1 = (char*)malloc(32);
char* pHeap2 = (char*)malloc(32);

printf("---enter main----\n");
HMODULE hModule = GetModuleHandle(_T("Kernel32.dll"));
printf("%p: Module (Kernel32.dll)\n", hModule);

FuncPtr pFunc = CreateThread;
printf("%p: FuncPtr (CreateThread)\n", pFunc);

DWORD tid1, tid2;
HANDLE hThread1 = CreateThread(NULL, 0, threadProc, (LPVOID)1, CREATE_SUSPENDED, &tid1);
HANDLE hThread2 = CreateThread(NULL, 0, threadProc, (LPVOID)2, CREATE_SUSPENDED, &tid2);

ResumeThread(hThread1);
WaitForSingleObject(hThread1, 5000);
CloseHandle(hThread1);
ResumeThread(hThread2);
WaitForSingleObject(hThread2, 5000);
CloseHandle(hThread2);

printf("%p: auto variable on main thread's stack\n", &a);
printf("%p: memory alloc on heap: pHeap1 (32 bytes)\n", pHeap1);
printf("%p: memory alloc on heap: pHeap2 (32 bytes)\n", pHeap2);
printf("%p: address of const data(\"hello world\")\n", pConstData);
printf("%p: global variable g_Temp1 (initialized)\n", &g_Temp1);
printf("%p: global variable g_Temp2 (not initialized)\n", &g_Temp2);
printf("%p: global variable g_Array (not initialized)\n", g_Array);
printf("%p: global variable g_Temp3 (not initialized)\n", &g_Temp3);
printf("%p: static variable nStatic1 (initialized)\n", &nStatic1);
printf("%p: static variable nStatic2 (initialized)\n", &nStatic2);
printf("%p: static variable nStatic3 (not initialized)\n", &nStatic3);
free(pHeap1);
free(pHeap2);
printf("---leave main----\n");
return 0;
}

在这个例子里我添加了全局变量，auto 类型的栈上临时变量，函数内的静态变量，以及新创建的线程的栈上的变量等。此程序产生的输入如下：

1 TestClass's constructor.
2 ---enter main----
3 7C800000: Module (Kernel32.dll)
4 7C810647: FuncPtr (CreateThread)
5 0052FFB0: auto variable on new thread's stack (thread: 1)
6 0062FFB0: auto variable on new thread's stack (thread: 2)
7 0012FF7C: auto variable on main thread's stack
8 00370FE0: memory alloc on heap: pHeap1 (32 bytes)
9 00371038: memory alloc on heap: pHeap2 (32 bytes)
10 00423148: address of const data("hello world")
11 00425B40: global variable g_Temp1 (initialized)
12 00428D78: global variable g_Temp2 (not initialized)
13 00428D68: global variable g_Array (not initialized)
14 00428D64: global variable g_Temp3 (not initialized)
15 00425B44: static variable nStatic1 (initialized)
16 00425B48: static variable nStatic2 (initialized)
17 00428D60: static variable nStatic3 (not initialized)
18 ---leave main----
19 TestClass's destructor.

首先，我们可以看到一个类的实例作为全局变量，它的构造函数在进入入口点函数（main）之前被调用，在main函数之后被析构。这显示这个过程应该是包装在main函数外层的函数，也就是 CRT 做的。

上面的输出给出了各个变量在进程空间中的地址（虚拟内存地址），因此我们再对照一下编译后的PE文件的 SectionHeader 的信息，使用我编写的文件格式查看器打开编译后的EXE文件，如下图所示：

根据PE文件中的信息:

ImageBase = 0x0040 0000;

SectionAlignment = 0x1000;

FileAlignment = 0x1000;

可以根据 section header 的信息知道，各个段在进程空间中的地址是（对比程序输出，可知全局变量和常量字符串在那个段范围内）:

section	From	To	Characteristics	备注
.text	00421790	00422790	可执行，可读	代码段
.rdata	00423000	00424777	可读	初始化数据段（常量）
.data	00425000	0042A730	可读，可写	初始化数据段（全局和静态变量）
.idata	0042B000	0042B7CC	可读，可写
.reloc	0042C000	0042CEC9	可读，可丢弃	基址重定位

上表是根据PE文件中的信息给出了进程空间中各个段的地址范围。因此我们根据运行时的输出情况，可以很容易的确定哪些变量具体位于进程空间的那个段中。例如针对这个具体的实例来说，全局变量和函数内静态变量位于 .data 段，常量字符串位于 .rdata 。

注意由于 SectionAlignment 和 FileAlignment 是相同的，因此文件中的内容和映射后，节之间的相对位置是没有变化的。节的特性被设置给内存页，因此如果代码中试图对内存执行没有权限的操作，例如对常量字符串的地址进行写入，系统就会告知错误。可以看到 section 的起始地址使用 sectionAlignment （默认 0x1000）对齐。数据段默认不具有共享属性，被映射以后数据是该进程空间所私有的。但共享的段则在所有进程实例中共享。可以设定某个段为共享，当使用一个DLL时，则数据通过DLL来给所有进程共享，共享意味着在所有进程空间中，该段被映射到相同的物理内存页。例如《windows 核心编程》中有一个例子，当创建多个进程实例，对话框上能实时更新的显示出当前实例的个数。（同时这也是作为用于控制只能运行一个进程实例的方法之一）：

// Tell the compiler to put this initialized variable in its own Shared
// section so it is shared by all instances of this application.
//
#pragma data_seg("Shared")
volatile LONG g_lApplicationInstances = 0;
#pragma data_seg()

// Tell the linker to make the Shared section readable, writable, and shared.
#pragma comment(linker, "/Section:Shared,RWS")

可以看出常量字符串代码中的"Hello World”位于.rdata节，该节是不可写的。全局变量和静态变量都位于.data节，可读可写。代码中已初始化的数据在节内位于靠近节前部地址较低的地方，未初始化的数据靠地址较高的地方。对于程序中的基本类型变量例如整形等，实际上它们从文件中被读入内存后就已具有了初值，相当于完成了初始化。但对于一个类的实例来说，对其初始化需要调用其构造函数。这些都需要在进入入口点函数之前完成。

因此现在我们可以明确：

char str[] = "Hello World";

含义是 str 数组是位于栈上的数组，然后从初始化段（只读）拷贝字符串内容到栈上的数组。（编译器可能对其用 DWORD 进行拷贝）

char *str = "Hello World";

str 是位于栈上的一个指针，指向初始化段的只读数据。

初学者一般不太容易立即区分出上面的代码在底层上的区别：前者是栈上的数组，数组空间在栈上分配。编译器会插入代码，在运行时把数据从只读数据段拷贝到栈上空间。所以前者的 str 是可写的。后者是栈上的一个指针变量，指向只读数据段上的某个位置（在C++里面这样的赋值合法，是为了照顾成千上万的已有 C 代码，此处参考了参考资料（5）《The C++ Programming Language》中的叙述）。后者的 str 是不可写的。如果试图修改它，在编译上是通过的，但运行时属于不确定行为。

我先后创建两个新的线程，是为了观察新线程的栈的位置，可以看到在这个例子中，在创建时我没有指定栈的大小，默认是 1MB。从低地址往高地址数，主线程的栈在进程空间中相当靠前，（中间的空隙属于堆），然后是那些 sections，然后此处剩下很大的一段空隙又基本上全部是属于堆。然后是新创建的线程的栈（默认 1MB），它们的地址看起来已经相当高。然后是那些被影射进来的DLL，系统 DLL 都经过了 Rebase，一般位于比较高地址的地方（靠近 2GB 边界），最后是系统控制的空间边界（0x80000000）。当然，默认情况下，是程序员和系统各占 4GB 空间的一半，但可以通过启动的配置参数让程序员负责的空间达到 3GB。因此上面的范例的进程空间大体如下图所示：

当然这个图只是针对这个控制台程序例子的特例而绘制，只是给出该例子中进程空间的示意图。图中箭头表示的是栈的增长方向。当一个进程中运行多个线程时，它们各自拥有独立的栈。当然这些栈之间由于位于相同的地址空间，所以它们彼此是可见的。因此一个线程可以把自己的栈上地址传递给其他线程进行处理，但这种地址随着线程退出就会失效，因此必须做线程同步，即阻塞式等待。例如不能使用 PostMessage 传递栈上的地址给其他窗口的窗口过程，而使用 SendMessage 是可行的。

当我们提到并发性和多线程安全，通常在针对一个函数讲时，是进程空间内的多个线程同时调用该函数是否会引发问题。并发还指多个线程对同一资源的访问和使用，例如数据库，文件等。如果一个函数是可重入的，则它不能直接或简介的使用，引用静态，全局性变量（尤其是对这些共享性变量的读写不是原子性的，且这些变量的值的准确性如果对于使用者来说是关键的状态性数据，则会引入诸如“脏读”等问题），也不能直接或简介调用不可重入的函数。栈上的一个 auto 类型变量是多线程安全的，是因为栈是属于线程的，彼此独立，因此 auto 类型变量对于线程来说相当于“私有数据”。对于递归函数，每一层递推都会在栈上增加一层 stackframe，因此函数内的临时变量位于其各自调用所属的 stackframe 中，也相当于彼此独立。

（2）系统调度，消息队列的基本单位。

这里我们提及的是进程和线程，不再考虑线程以下的概念。考虑下面的问题：

2.1 拥有消息队列的基本单位是什么？A。窗口；B。线程。

答案是线程。但通常我们更容易把消息队列和窗口关联在一起，这仅仅是因为事件驱动给我们的一种主观表象。由于调度的基本单位是线程，因此处理消息和拥有消息队列的基本单位也是线程。系统派送消息的目标，是把消息送到创建窗口的线程所拥有的消息队列。然后该线程被调度得到时间片，由消息循环（DispatchMessage）间接调用该窗口的窗口过程函数。但一个线程不一定拥有消息队列，例如只专注于运算不负责接受消息控制的后台线程，只有线程调用 PeekMessage，GetMessage 一类的函数时，系统才会为这个线程创建消息队列。拥有消息队列的线程也不一定会创建窗口，但是创建窗口的线程就会接收到和窗口有关的各种消息。

总结一下，线程中根据其功能又可以大致的分为主线程（或者在GUI程序中通俗的理解为 UI 线程）和后台线程。消息中的一部分属于窗口消息，这些消息是和一个具体的窗口关联并以创建该窗口的线程的消息队列作为目标的（最终线程的消息循环负责引发对窗口过程的调用，即 DispatchMessage），但并不是所有的消息都会和具体窗口关联。例如普通的线程消息（而一个线程也可能不会创建任何窗口）。窗口消息中的一部分又可以属于对话框消息。

2.2 比较特殊的几个消息：WM_MOUSEMOVE, WM_TIMER, WM_PAINT, WM_QUIT; (待完成）

线程消息分为三种类型：incoming sent message; posted message; input message; 在标准术语里面，第一种被称为非队列消息，后两种称为队列消息，也就是被理解为“位于消息队列中的消息”。

参考资料：

（1）《程序员的自我修养》，俞甲子等。

（2）“Billy Belceb 病毒教程Win32篇”（选自《看雪学院五周年纪念收藏版》）, Billy Belceb。

（3）《windows核心编程》, Jeffery Richer.

（4）《Tho Old New Things》, Raymond Chen.

（5）《The C++ Programming Language》，BS。

【补充说明】

本文已有的评论，因为涉及到有具体所指的个人主观性意见，于技术探讨交流上没有任何积极意义，因此不在技术博客保留，已转移到163博客的以下地址进行备份性保留（可以点击以下地址观看原有评论）：

http://blog.163.com/jinfd@126/blog/static/62332277201211104431759/

本文评论在此处被删除的原因是，其内容和技术或讨论主题无关（例如无实质内容，明显针对人的主观评价等）。

--hoodlum1980，2012年2月1日。

本文链接

ZOL 简单题集合（三）

2011-11-18T12:17:00Z

（1）ZOL1045. HangOver (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1045

在桌子边码扑克牌，给出表示扑克牌延伸出桌子的距离的浮点数，问需要多少张牌。

#include <stdio.h>
int GetCardCount(double c)
{
int result = 1;
double dx = 0.5;
while(dx < c)
{
result++;
dx += 1.0/(result + 1.0);
}
return result;
}
int main(int argc, char* argv[])
{
double c;
int result;
while(1)
{
scanf("%lf", &c);
if(c < 0.001) break;
result = GetCardCount(c);
printf("%d card(s)\n", result);
}
return 0;
}

（2）ZOL1061. Web Navigation (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1061

模拟浏览器的前进后退功能，给出初始时刻的当前页面，然后经过一系列命令：访问某个url，前进，后退，如果命令有效，输出当前页面。

#include <stdio.h>
#include <string.h>

char sForw[100][72];
int pForw;
char sBack[100][72];
int pBack;

int main(int argc, char* argv[])
{
int n, i;
char curUrl[72], line[96];

scanf("%d", &n);

for(i = 0; i < n; i++)
{
//case和case之间的空行
gets(line);
strcpy(curUrl, "http://www.acm.org/");
pForw = -1;
pBack = -1;
while(1)
{
gets(line);
if(strcmp(line, "BACK") == 0)
{
//If the backward stack is empty, the command is ignored.
if(pBack < 0) printf("Ignored\n");
else
{
//Push the current page on the top of the forward stack.
++pForw;
strcpy(sForw[pForw], curUrl);

//Pop the page from the top of the backward stack,
//making it the new current page.
strcpy(curUrl, sBack[pBack]);
--pBack;

printf("%s\n", curUrl);
}
}
else if(strcmp(line, "FORWARD") == 0)
{
//If the forward stack is empty, the command is ignored.
if(pForw < 0) printf("Ignored\n");
else
{
//Push the current page on the top of the backward stack.
++pBack;
strcpy(sBack[pBack], curUrl);

//Pop the page from the top of the forward stack,
//making it the new current page.
strcpy(curUrl, sForw[pForw]);
--pForw;
printf("%s\n", curUrl);
}
}
else if(strncmp(line, "VISIT", 5) == 0)
{
//Push the current page on the top of the backward stack,
++pBack;
strcpy(sBack[pBack], curUrl);

//and, make the URL specified the new current page.
strcpy(curUrl, line + 6);

//The forward stack is emptied.
pForw = -1;
printf("%s\n", curUrl);
}
else if(strcmp(line, "QUIT") == 0)
{
break;
}
}
//case 和 case 之间用空行隔开
//注意这个if条件，如果没有，则导致PE！（多打印一个空行）
if(i < n - 1) printf("\n");
}
return 0;
}

（3）ZOL1067. Color Me Less (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1067

给出16个RGB值作为关键颜色，对后续给出的颜色，要求用欧几里德距离最短的方式，被映射到哪个关键颜色上。

include <stdio.h>

typedef struct _tagColor
{
int r;
int g;
int b;
} Color;

Color colors[16];

int GetMappedIndex(int r, int g, int b)
{
unsigned int distance = 0xFFFFFFFF;
unsigned int temp;
int i, index = -1;
for(i = 0; i < 16; i++)
{
temp = (r-colors[i].r) * (r-colors[i].r);
temp += (g-colors[i].g) * (g-colors[i].g);
temp += (b-colors[i].b) * (b-colors[i].b);
if(temp < distance)
{
distance = temp;
index = i;
}
}
return index;
}

int main(int argc, char* argv[])
{
int i, r, g, b;
for(i = 0; i < 16; i++)
{
scanf("%d %d %d",
&colors[i].r, &colors[i].g, &colors[i].b);
}
while(1)
{
scanf("%d %d %d", &r, &g, &b);
if(r == -1) break;
i = GetMappedIndex(r, g, b);
printf("(%d,%d,%d) maps to (%d,%d,%d)\n",
r, g, b, colors[i].r, colors[i].g, colors[i].b);
}
return 0;
}

（4）ZOL1123. Triangle Encapsulation（0.5）

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1123

依次给出一个三角形按逆时针方向排列的三个顶点的坐标（所有坐标范围在 -9 ~ 9 之间），要求求平面上被这个三角形完全围在内部的所有整数坐标的点。而且这道题目对输出格式有特别要求，不好描述，就是输出的点排列的就像他们在笛卡尔座标中的位置那样。

解法：首先这道题目求解一个点是否在三角形，可以用常规的点在多边形内的射线法。但还可以用线段旋转方向（即叉积）来判断，如果点P在三角形ABC内部，则AB，BC，CA旋转到P的时针方向必然全都相同。如果在外部，则必定不满足这个条件。而且此题还明确说明，三个点ABC是逆时针排列的，所以三条边从逆时针转过去，转到P点如果都是“右转”，则说明点P在三角形内。如果P在三角形的边上，叉积为0。因此只要遍历三角形的外接矩形内的所有整数坐标点，依次判断即可。最后为了按题目要求的格式进行输出，采用一个辅助队列缓存所有解，最后得到了最左侧的点的位置以后，所有解的打印位置也就确定了。

#include <stdio.h>

#ifndef __min
#define __min(a, b) ((a)<(b)? (a):(b))
#endif

#ifndef __max
#define __max(a, b) ((a)>(b)? (a):(b))
#endif

//
typedef struct _tagPOINT
{
char x;
char y;
} POINT;

POINT pts[90];

int pts_top; //Queue 指针

// (Pi->Pk) * (Pi->Pj) 从 PI-PK 转向 PI-PJ 的方向
// > 0: 左转
// < 0: 右转
// = 0: 共线
int Direction(int xi, int yi,
int xj, int yj,
int xk, int yk)
{
return (xk-xi)*(yj-yi) - (xj-xi)*(yk-yi);
}

int main(int argc, char* argv[])
{
//三角形的三个顶点（逆时针方向）
int x0, y0, x1, y1, x2, y2, x, y;
int left, top, right, bottom;
int min_x, i, j, cur_y;

printf("Program 4 by team X\n");

while(scanf("%d %d %d %d %d %d",
&x0, &y0, &x1, &y1, &x2, &y2) != EOF)
{
//初始化case
pts_top = -1;
min_x = 10;

left = __min(__min(x0, x1), x2);
top = __max(__max(y0, y1), y2);
right = __max(__max(x0, x1), x2);
bottom = __min(__min(y0, y1), y2);

//在矩形整数阵列中搜寻三角形内部的点
for(y = top; y >= bottom; y--)
{
for(x = left; x <= right; x++)
{
if( Direction(x0, y0, x1, y1, x, y) <= 0) continue;
if( Direction(x1, y1, x2, y2, x, y) <= 0) continue;
if( Direction(x2, y2, x0, y0, x, y) <= 0) continue;

//这是一个内部的点
++pts_top;
pts[pts_top].x = x;
pts[pts_top].y = y;

//更新最左的点
if(x < min_x) min_x = x;
}
}

//打印输出结果！
cur_y = -10; //当前y坐标
for(i = 0; i <= pts_top; i++)
{
//换行了?
if(pts[i].y != cur_y)
{
cur_y = pts[i].y;

//不是第一行，则换行！
if(i > 0) printf("\n");

//本行前面的前导打印多少个空格？
for(j = 0; j < ( pts[i].x - min_x ) * 9; j++)
printf(" ");
}
else
{
//没有换行，则在两个点之间打印一个空格
if(i > 0) printf(" ");
}
printf("(%2d, %2d)", pts[i].x, pts[i].y);
}

//case结束后还需要输出一个空行！
printf("\n\n");
}
printf("End of program 4 by team X\n");
return 0;
}

（5）ZOL1244. Definite Values (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1244

最开始只有变量 a 有确定值，执行一系列赋值语句后，要求按字典顺序，输出所有有确定值的变量。如果任何变量都没有确定值，输出 none 。但这个题题目里没有明确的说清楚，就是所有变量名都是单字母，有了这个假设这个题目其实非常简单。但如果我们不考虑这一点，而是变量名任意，那显然还要建立符号表，又要变得更麻烦。

#include <stdio.h>

char variables[26];

int main(int argc, char* argv[])
{
char line[32];
int n, i, nCase = 0, charCount;
while(1)
{
scanf("%d", &n);
if(n == 0) break;

getchar(); /* 取走回车符号 */
++nCase;

/* Init: a is definite. */
variables[0] = 1;
for(i = 1; i < 26; i++)
variables[i] = 0;

for(i = 0; i < n; i++)
{
gets(line);
variables[line[0]-'a'] = variables[line[4]-'a'];
}

printf("Program #%d\n", nCase);
charCount = 0;
for(i = 0; i < 26; i++)
{
if(variables[i] > 0)
{
line[charCount] = 'a' + i;
charCount++;
}
}
if(charCount > 0)
{
for(i = 0; i < charCount; i++)
{
printf("%c ", line[i]);
}
printf("\n\n");
}
else printf("none\n\n");
}
return 0;
}

（6）ZOL1858. Soundex (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1858

把单词按照发音归类，给出一个单词的拼写，按照规则求出这个单词的一个发音归类代码。

#include <stdio.h>
#include <string.h>

void GetSoundexCode(char* buf, const char* word)
{
int i;
char last_code = -1, cur_code;;
char* strs[6] = { "BFPV", "CGJKQSXZ", "DT", "L", "MN", "R" };
char* pDest = buf;
const char* pSrc = word;
while(*pSrc)
{
cur_code = -1;
for(i = 0; i < 6; i++)
{
if(strchr(strs[i], *pSrc) != NULL)
{
cur_code = '1' + i;
break;
}
}
if(last_code != cur_code && cur_code > 0)
{
*pDest = cur_code;
++pDest;
}
last_code = cur_code;
++pSrc;
}
//null-terminator!
*pDest = 0;
}

int main(int argc, char* argv[])
{
char line[24], code[24];
while(gets(line) != NULL)
{
GetSoundexCode(code, line);
printf("%s\n", code);
}
return 0;
}

备注：题目后面括号内的数字为我的主观认定难度值。

本文链接

[发布] QQGame 连连看辅助工具（限制功能版）

2011-11-18T11:12:00Z

前几天想起了这个想法，然后最近两天开发了这个工具，就是用于 QQGame 中的连连看的辅助工具。本来是想把全部代码都公开的，但是我在调试程序的时候注意到腾讯在qqgame中宣传卖那些游戏道具。所以我的想法就改变了下，不想影响腾讯卖这些道具来赚钱，所以我把原来完整功能版的版本又加上了一些限制。

辅助工具实现的功能包括：全自动点击，自动重排（当方块无解时），显示可点击方块提示（相当于官方的指南针功能），模拟单步点击。

首先进入 QQGame，连连看，开始游戏后如下图所示：

启动工具后的界面如下图所示，点击任务栏按钮即可。具体用法参考任务栏的tooltip和压缩包中的简要说明。

最后我为这个版本加了以下限制，使他不至于惹上“影响别人赚钱”的嫌疑（虽然我一向非常鄙视腾讯）。主要限制如下：

（1）自动点击的速度限制在 1 秒一次点击，但可以暂时体验 500 ms 速度。更快的点击速度全部被禁用！
（2）提示数量超过16个（相当于道具中的指南针）时，每次需要输入验证码才能继续。
（3）快速连击“消掉一对方块”的次数如果超过10次，则需要输入验证码才能继续。此处快速连击是指两次点击时间间隔小于 1 秒。

作为兴趣，验证码对话框是我今天加上去的，显然这个手段也是我和腾讯学习来的，如下图所示：

这个对话框比较简单，我用代码动态生成一个图片显示在上面，当然题目也是动态生成的，题目主要是 100 以内的加减乘除法。图片中我放了随机的贝塞尔彩色线条作为干扰。问题里面的每个字符采用了位置和角度的轻微抖动，但是没有经过变形，因为我是用 GDI 函数绘制的文本。

下面介绍下这个辅助工具的一些内容，首先我寻找到游戏中的窗口后，需要确定的棋盘网格的内容，最早我的想法是用4到5个关键点采样来检测方块。但是后来我实际开发时发现，比较幸运的是，能选取特定的方块坐标，可以仅仅用一个采样点就能区分出所有方块。满足这样高区分度条件的采样点一共有四个，被我用代码寻找了出来。检测方块时，相比之前的“快速美女找茬”工具，这次我用了效率更高些的直接对位图数据块寻址来检测。当然，这要求对位图中的像素定位（即在内存数据块中定位到某个位置的某个通道）需要非常熟悉，我在自己的博客中介绍过多次，这里就不重复了。

确定了棋盘网格的内容后，就是这个工具的核心，即寻解的方法。从这点上来说，其实程序的寻解和人的寻解本质上并没有什么不同，只不过两者的侧重点稍有区别。在程序中，在确定棋盘网格的过程中，我就建立了对每一种方块都建立了一个双向链表（采用双向链表的原因是因为随着寻解的过程，需要频繁的进行节点脱链操作），去存储他们的坐标。这样的目的是不需要反复的盲目扫描棋盘，而是把精力集中到判断两个方块是否有通路就可以了。游戏中的方块多达 40 多种，所以我用一个指针数组来存储所有链表的 Head。取决于游戏的设计，链表数量较多，但长度较短（例如为 4 ）。所以尽管寻解算法的时间复杂度相对与链表长度为 O(n^2)，但整个求解过程依然是感觉很快，后台运算的线程感觉是瞬间就退出的，以至于我觉得哪怕是用户需要的时候再算时间都来得及，根本不需要另起一个线程来求解了。当完全不使用定时器延时时，令我感到吃惊的是，仿佛是就点了一下，然后所有方块就全部消失的无影无踪了，这根本违背了我们平时观看到的场景印象。由于方块消失的太快，整个游戏窗口都弥漫在一团烟雾效果中。

下面我给出的是连连看的“通路”判断方法，这是所有连连看的共同游戏规则。不管是什么连连看游戏，你都能在代码中看到这个函数，只不过可能形式有多种多样而已。由于分别在两个方向上检测，所以两部分的代码惊人的一致，这也可能让我这样有完美主义倾向的人感觉不爽，想把两部分代码合并成一个循环（我们把网格指针的偏移作为变量，分别存放到一个含有两个元素的数组中即可，例如如果我们要在水平方向上移动，偏移量是+-1，在垂直方向上移动，偏移量是+-行宽度），这当然是可以的，但我想可能会牺牲掉一部分代码可读性。下面的代码非常简洁，它的主题是来自我以前发表在 BCCN上的 TC2.0版的连连看（DOS贴图版）中的代码：

//连连看游戏的核心算法
BOOL CanConnect(char map[11][19], int row1, int col1, int row2, int col2)
{
int path, i, j, left, right, top, bottom;
int min1, min2, max1, max2;
//-----------------查找水平方向----------------------------
min1 = max1 = col1;
min2 = max2 = col2;
while(min1 - 1 >= 0 && map[row1][min1 - 1] == 0) min1--;
while(min2 - 1 >= 0 && map[row2][min2 - 1] == 0) min2--;
left = __max(min1, min2);

while(max1 + 1 < 19 && map[row1][max1 + 1] == 0) max1++;
while(max2 + 1 < 19 && map[row2][max2 + 1] == 0) max2++;
right = __min(max1, max2);

//检查两条水平线之间是否有可连通的垂直线
for(i = left; i <= right; i++)
{
path = 0;
for(j = __min(row1, row2) + 1; j < __max(row1, row2); j++)
{
path += map[j][i];
if(path > 0) break;
}
if(path == 0)
return TRUE;
}

//-----------------查找垂直方向----------------------------
min1 = max1 = row1;
min2 = max2 = row2;
while(min1 - 1 >= 0 && map[min1 - 1][col1] == 0) min1--;
while(min2 - 1 >= 0 && map[min2 - 1][col2] == 0) min2--;
top = __max(min1, min2);

while(max1 + 1 < 11 && map[max1 + 1][col1] == 0) max1++;
while(max2 + 1 < 11 && map[max2 + 1][col2] == 0) max2++;
bottom = __min(max1, max2);

//检查两条垂直线之间是否有可连通的水平线
for(j = top; j <= bottom; j++)
{
path = 0;
for(i = __min(col1, col2) + 1; i < __max(col1, col2); i++)
{
path += map[j][i];
if(path > 0) break;
}
if(path == 0)
return TRUE;
}
return FALSE;
}

下面是后台线程的代码，调用了上面的方法，过程类似绘制“金刚石”图形（所有顶点彼此连线），和冒泡排序一类的时间复杂度相同。

//用于寻找可点击方块的后台线程，进入线程时，map 已经初始化好了
DWORD WINAPI MyThread(LPVOID lpParameter)
{
PMYTHREAD_PARAMS pMyParams = (PMYTHREAD_PARAMS)lpParameter;
int i;
HWND hwnd = pMyParams->hWndUI;
PCELLPOS pNode1, pNode2;
BOOL bAllListIsNull;
BOOL bFind_One_Solution; //是否找到了一个解
while( !bThreadStopSignal )
{
bAllListIsNull = TRUE;
bFind_One_Solution = FALSE;

//此处暴力的盲目搜索就是了~。~ 有时间的话需要让此处更“智能化”！
//pCellPos[0]就是代表空白位置的链表，永远为 NULL （浪费掉了）
for(i = 1; i < CELL_TYPE_COUNT; i++)
{
//在链表中搜索是否可点击类似金刚石画法，时间复杂度：O(n^2)
if(pCellPos[i] != NULL)
{
bAllListIsNull = FALSE; //存在链表不为空
pNode1 = pCellPos[i];
while(pNode1 != NULL)
{
pNode2 = pNode1->pNext;
while(pNode2 != NULL)
{
if(CanConnect(map, pNode1->row, pNode1->col, pNode2->row, pNode2->col))
{
//找到了一对可点击方块
map[pNode1->row][pNode1->col] = 0;
map[pNode2->row][pNode2->col] = 0;

CLICKINFO cInfo;
cInfo.row1 = pNode1->row;
cInfo.col1 = pNode1->col;
cInfo.row2 = pNode2->row;
cInfo.col2 = pNode2->col;
SendMessage(hwnd, WM_CLICKINFO_FIND, (WPARAM)pMyParams->bIsAutoClick, (LPARAM)(&cInfo));

RemoveNodeFromList(&pCellPos[i], pNode1);
RemoveNodeFromList(&pCellPos[i], pNode2);

bFind_One_Solution = TRUE;
break;
}

//由于两个Node都已经被释放了，所以必须立即结束对当前链表中的搜索。
if(bFind_One_Solution)
break;

pNode2 = pNode2->pNext;
}

if(bFind_One_Solution)
break;
pNode1 = pNode1->pNext;
}
}
}

//已经没有方块了？
if(bAllListIsNull)
{
//发送消息，所有解已经搜索完毕，游戏可以胜利清空所有方块
PostMessage(hwnd, WM_SOLUTION_COMPLETE, 0, 0);
break;
}
//对所有链表都搜索完毕了，但找不到解，需要重排！
else if(!bFind_One_Solution)
{
PostMessage(hwnd, WM_NEED_RERANGE, 0, 0);
break;
}
}
bThreadRunning = FALSE;
return 0;
}

最后这里的双向链表，还有队列等辅助数据结构当然都可以选用STL中的模板，而我没有用STL，此处全部是自写的。这样的好处可能就是非常直观吧，所有代码都在自己的眼皮底下，比较放心罢了。这里给出几个双向链表操作函数，实际上非常简单非常简短。

//释放某一个链表，最后把表头置为NULL
void FreeList(PCELLPOS* ppHead)
{
PCELLPOS pTmp = NULL;
PCELLPOS pNode = *ppHead;
while(pNode != NULL)
{
pTmp = pNode->pNext;
free(pNode);
pNode = pTmp;
}
(*ppHead) = NULL;
}

//把一个新节点挂接到指定链表上，如果链表为空，则会被创建！
void AddNodeToList(PCELLPOS* ppHead, int row, int col)
{
PCELLPOS pNewNode = (PCELLPOS)malloc(sizeof(CELLPOS));
pNewNode->row = row;
pNewNode->col = col;
pNewNode->pForward = NULL;
pNewNode->pNext = NULL;

if(*ppHead == NULL)
{
*ppHead = pNewNode;
return;
}
else
{
//找到tail节点，然后挂接上去！
PCELLPOS pCur = *ppHead;
while(pCur->pNext != NULL)
pCur = pCur->pNext;

pNewNode->pForward = pCur;
pCur->pNext = pNewNode;
}
}

//从链表中把指定的节点除去，如果是最后一个节点，则会导致该链表被置为 NULL
void RemoveNodeFromList(PCELLPOS* ppHead, PCELLPOS pNode)
{
//是表头吗
if(pNode == *ppHead)
{
*ppHead = pNode->pNext;
}

// [Forward] <--> [X] <--> [Next]
// [Forward] <-----------> [Next]

if(pNode->pForward != NULL)
pNode->pForward->pNext = pNode->pNext;

if(pNode->pNext != NULL)
pNode->pNext->pForward = pNode->pForward;

free(pNode);
}

其中，提示可点击方块时，没有直接用窗口 DC 或者屏幕 DC，我用的是 SetWindowRgn 方法（如果用 LayeredWindow 的 COLOR_KEY 会有闪烁，所以改为用 Window RGN）。

最后，暂时发布工具的可执行文件，该工具是采用VS2005 + WIN32 Platform SDK开发，完全绿色的。但它在关闭的时候会在自身所在文件夹下面防止一个 INI 配置文件，实际上我在程序里已经写好了所有默认值，但把 INI 文件放在程序所在位置，也是为了让用户知道那些地方可以配置。但有一项我写死在代码里面了，就是方块样本集合位图的行容量固定为 8，这样的目的是我可以对除法和取余（MOD）用位操作来实现。

下载链接：http://files.cnblogs.com/hoodlum1980/LLKHelper.rar

相同性质文章：《快速“美女找茬”（辅助工具）》

【补充说明】 by hoodlum1980 @ 2011-11-20

我发现有些人在肆无忌惮的使用“秒杀”级别的疑似外挂。所以也促使我进行改进。主要是加了系统全局性热键，程序自身的快捷键（因为按键的反应速度要比鼠标点击快），在比拼秒杀速度的时候取消开启线程，而是合并到 UI 线程一次性完成。改进搜索解的循环方式，从每次复位改为轮转式。最终我发现实际上成了反应速度的比拼。假使秒杀耗时是 0.1 秒（具体到底多少可能也无法精确测量），那么如果谁反应速度稍微快 0.1 秒，先行启动，就会赢。所以同为秒杀速度，由于秒杀耗时极短，远小于人能观察出的时间间隔，所以在算法上可能已经很难拼出优势来了。比如从其他方向下手进行改进。当然我也考虑了自动对别人应用各种障碍型道具，但是如果起跑反应慢一点的话，实际上一切都没用，因为你根本不会有应用道具的时间，游戏已经被对方结束了。反正已经够快了，估计暂时就这样了~。~

本文链接

ZOL3505 ( Yet Another Set of Numbers ) 解题报告

2011-11-09T19:16:00Z

ZOL 3505：Yet Another Set of Numbers

地址：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3505

题意：有一个数字集合，集合中的数遵循以下规则：

( 1 ). 每个数字的最高位不是 0 ;

( 2 ). 每个数字包含最多 N 位，且只有 0，1，2，3 这四个数字可能出现（0 < N < 20）;

( 3 ). 每个数字的相邻位不同（例如：301是有效的，300不是）;

( 4 ). 数字比较大小和他们的字符串比较方法相同（例如：1 < 123 < 20 < 21 < 3）.

问题是，给出这个集合中的一个数字 B，从数字 B 开始，在这个集合中向前数数到第 K 个数字时输出这个数字（K > 0）;

原文叙述：求满足以下条件的数字A：在集合中恰好有 ( K - 1 ) 个数字大于 A 小于 B （题目保证存在解）;

时空限制：Time Limit: 2 Seconds; Memory Limit: 65,536 KB;

例如：当 N = 2 时，这个集合中一共有 12 个数字，依次是：

1 < 10 < 12 < [ 13 ] < 2 < 20 < 21 < 23 < [ 3 ] < 30 < 31 < 32; ----（序列中A和B用方括号标示）

当 B = 3 时，K = 5 时，从集合中的 3 向前数到第 5 个数字时是 13，因此应该输出 13。

（1）第一个解法，模拟法（Result：TLE）

我想到的第一个解法是，观察这个序列的规律，然后用模拟数数的方法，依次向前数，数到第 K 个为止即可。

考虑集合中最大的一个数字的字符串表示，显然是以下形式 "3232..."（长度为 N）。

因此可以给出下面的模拟数数的第一个解，模拟法代码如下： ( X. 以下代码算法时间超出题目限制 )

#include <stdio.h>
#include <string.h>

int length; /*当前数字的字符串长度*/
char Num[24];

/*检测当前数字是否合法*/
int IsNumValid()
{
int i;

// 第一位不能为0
if(Num[0] == '0')
return 0;

//相邻位不能相同
for(i = 0; i < (length - 1); i++)
{
if(Num[i] == Num[i+1])
return 0;
}
return 1;
}

void GetNextNum(int N)
{
char _MaxChars[4] = "32";
int i;
do
{
/* 如果最后一个字符是0，则去掉结尾的0 */
if(Num[length - 1] == '0')
{
Num[length - 1] = 0;
length--;
continue;
}

//ELSE: 当前字符递减后，立即扩展到 N 的长度
Num[length - 1] = Num[length - 1] - 1;
for(i = length; i < N; i++)
{
Num[i] = _MaxChars[ (i - length) & 1 ];
}
length = N;
}
while( !IsNumValid() );
}

int main(int argc, char* argv[])
{
int N = 0; /*字符串最大长度, 0 < N < 20 */
int K = 0; /*往下数第K个数字*/
int index; /*往下数多少个*/
while(scanf("%d %d", &N, &K) != EOF)
{
scanf("%s", Num);
length = strlen(Num);
for(index = 0; index < K; index++)
{
GetNextNum(N);
}
printf("%s\n", Num);
}
return 0;
}

但第一个方法提交后超时。显然，如果 N 比较大，这个集合中的数字数量是非常大的，因此这时 K 也可以取得很大。而这个方法是一个笨方法，是一个一个数字向前找，且还要进行数字合法校验，时间效率很低。当 N 和 K 都比较大时，这个方法在速度上显然不能满足要求。因此不能使用笨方法，必须找出这个序列中蕴藏的内在规律。

（2）速度更快的解法：使用三叉树模型（Result：MLE）

观察这个序列的规律，考虑数字用字符串进行比较的特点，比较时，越高（靠左）的位越重要，越低的位则不重要。因此考虑把每一位看作一个节点，则低位属于高位的子节点，父子节点彼此属于相邻的位，显然有每个节点含有三个子节点（由于每一位上只能在 0，1，2，3 中选择，且不能与父节点数字相同），因此形成一个满的三叉树。

每个节点代表了序列中的一个数字，把从根节点到该节点的路径所经过的节点依次输出，就是这个数字的字符串表示。当 N = 2 时，该树如下图所示：

题意中的规则（2）规定了树的高度，规则（1）和（3）使该树从完全四叉树变成完全三叉树，规则（1）去掉了“0” 子树，规则（3）缩减了子节点个数。

考虑两个树节点 N1 和 N2 之间的排序关系（比较时，深度小的节点比深度大的节点重要），注意和字符串比较算法进行对比：

（a）如果 N1 节点位于 N2 的路径上，则路径短的节点小；( eg. 123 < 1230 )

（b）如果 N1 和 N2 在节点 N' 处开始分离（从根节点到 N’ 处路径重合），则进入 N' 左侧子树的小于进入 N' 右侧子树的。( eg. 121230 < 123 )

（c）从前两点可知，此树前序遍历（先遍历当前节点的所有子节点，然后访问当前节点），即为数集合的有序排列。（对比：二叉查找树的中序遍历为有序序列）

图中节点圆圈中的黑色数字就是用于组成输出数字的位（num）。为了统计树中每个子树所代表的子序列中的数字个数，我们在每个节点上加一个属性 sum，表示以该节点为根的子树所表征的数字组成的子序列的数字个数，在图中用节点旁边的红色数字表示。显然，节点的 sum，就是以该节点为根的子树所包含的所有节点的数目，因为每个节点都一对一的代表集合中一个数字，用节点路径表示（类似贪心算法中的霍夫曼编码和霍夫曼树的关系）。由于输出节点路径时，根节点无需输出 ( dummy node )，因此根节点用阴影填充，和子节点的连线用虚线表示。

显然，最底层的所有叶子节点（深度为 N + 1）仅代表一个数字，其 sum = 1，对非叶子节点，其三个子节点的 sum 值相同，再加上自身节点代表的数字，因此有：

Node.sum = Node.Child[0].sum * 3 + 1 ;

因此对于本题目来说，可以创建这样一个三叉树，对于给定的数字 B，设它对应的是树中的节点 B，从 B 节点开始，向前回退寻找目标节点 A。

为了清楚的描述算法，我用节点游标的形式来阐述该算法（在代码中可以是一个节点的指针，表示当前所处的位置），并做如下定义：

(a). K 的逻辑含义是，代表当前节点和目标节点 A 的“距离”。寻找过程中 K 的值将不断减小，直到为 K = 0 ，表示到达目标节点A。

(b). 游标指向的改变称为 “移动到” 某个节点。

(c). 如果节点需要处理（即调整 K 值），称为“访问” ( visit ) 该节点。

(d). 如果节点不需要处理（即不需要调整 K 值），称为“经过” ( pass ) 该节点。

则算法（2）的基本步骤（GetNodeBySteps ）如下：

(2.1). 令游标指向起始节点 B; （这是准备工作，接下来将“向前”寻找节点 A）

(2.2). 如果所在节点已经是兄弟节点中的老大（位于最左侧），则（向上）“访问”其父节点，令 K = K - 1; 跳到（2.6）; （请思考为什么此处 K 的递减值是 1 而不是 Node.sum？）

(2.3). 如果所在节点有哥哥节点，则（向左）移动到它的哥哥节点; （接下来在（2.4）和（2.5）中一定能找到一个可访问节点，请思考这是为什么？）

(2.4). 如果 Node.sum <= K ，则“访问”该节点，令 K = K - Node.sum，跳到（2.6）; （备注：Node.sum < K 时说明 A 不位于该节点为根的子树中）

(2.5). 如果 Node.sum > K，（备注：说明 A 位于 Node 为根的子树中）则连续的（向下）移动到当前节点的（最右侧）最幼子节点，直到找到符合（2.4）中的条件（Node.Sum <= k）的节点为止，然后用和（2.3）的相同方法“访问”它：令 K = K - Node.sum; （这是一个嵌在内部的 while 循环）

(2.6). 如果 K != 0，则重复（2.2）~ （2.5）。直到 K = 0 为止，此时我们到达的节点就是目标节点 A，输出节点 A 的路径就是问题的解;（这是最外层的 while 循环）

总结上面的探查方法：如果一个节点是被访问节点，则绝不会再进入它的任何子树；当寻找下一个可访问节点时，如果左侧有哥哥节点，则一定先探查哥哥节点（如果哥哥节点没有超越目标，则访问它；否则进入它的幼子子树继续探查），否则访问父节点（此时父节点必是可访问节点）。

上面的语言接近伪码，括号内的描述属于导航时的逻辑方向或备注性说明。显然（2.2）~（2.6）整体是一个 while 循环，其中（2.5）是嵌在其内的又一个 while 循环。上诉步骤即对应的是代码中的 GetNodeBySteps 方法，参数 step 即 K。

【思考】：为何（2.2）向父节点回退时的访问和（2.4）和（2.5）中的访问方法不同，前者令 K 递减 1，后者令 K 递减 Node.sum。

（提示：前者，当子节点向父节点“回退”时，子节点为根的子树位于其父节点所代表的子树中。后者则进入到了另一个独立的子树。）

第二个解法的代码（三叉树方法），如下所示： ( X. 以下代码内存使用超出题目限制 )

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

typedef struct _NODE
{
char index; /* 在兄弟节点中的排行索引 */
char num; /* 节点数字, 只能取下列值 0,1,2,3，为 'R' 时表示 root */

int sum; /* 1 + 3 + 9 + ... + 3^k */

_NODE* parent; /* 父节点 */
_NODE* child[3]; /* 子节点 */
} NODE, *PNODE;

/* 递归函数： N - 树的深度（不含根节点的深度） */
void AddChildren(PNODE pNode)
{
int i, _num = 0;;
PNODE pChild = NULL;
pNode->sum = pNode->sum * 3 + 1;

if(pNode->child[0] == NULL)
{
for(i = 0; i < 3; i++)
{
pChild = (PNODE)malloc(sizeof(NODE));
memset(pChild, 0, sizeof(NODE));
pChild->parent = pNode;
pChild->index = i;
pChild->sum = 1;

/* 回避父节点数字 */
if(pNode->num == _num) _num++;
pChild->num = _num++;

pNode->child[i] = pChild;
}
}
else
{
for(i = 0; i < 3; i++)
AddChildren(pNode->child[i]);
}
}

PNODE CreateTree(int depth)
{
int i;
PNODE pRoot = (PNODE)malloc(sizeof(NODE));
memset(pRoot, 0, sizeof(NODE));
pRoot->num = 0; /*根节点数字为0，可以让第一层子节点为1，2，3 */
pRoot->sum = 1;
for(i = 0; i < depth; i++)
{
AddChildren(pRoot);
}
pRoot->num = 'R';
return pRoot;
}

/* 释放树占用的内存（递归函数） */
void FreeTree(PNODE pNode)
{
int i;
for(i = 0; i < 3; i++)
{
if(pNode->child[i] != NULL)
{
FreeTree(pNode->child[i]);
}
}
free(pNode);
}

/* 从节点 pStart 向前追溯到某个节点 */
PNODE GetNodeBySteps(PNODE pRoot, PNODE pStart, int step)
{
int remainStep = step;
int index;
PNODE pCurNode = pStart, pNextNode = NULL;

while(remainStep > 0)
{
/*找到下一个不大于 remainStep 距离的节点*/
index = pCurNode->index;
if(index == 0)
{
/* 向上返回一层时，只-1 */
pCurNode = pCurNode->parent;
remainStep--;
continue;
}
pNextNode = pCurNode->parent->child[ index - 1];
while(pNextNode->sum > remainStep)
{
/* 向下进入最右侧的最小子节点分支 */
pNextNode = pNextNode->child[2];
}
pCurNode = pNextNode;
remainStep -= pCurNode->sum;
}
return pCurNode;
}

/* path: 字符串形式例如“12301” */
PNODE GetNodeByPath(PNODE pRoot, char* path)
{
int i;
char *p = path;
PNODE pCur = pRoot;
while(*p)
{
for(i = 0; i < 3; i++)
{
if(pCur->child[i]->num == (*p - '0'))
{
pCur = pCur->child[i];
break;
}
}
++p;
}
return pCur;
}

/* 借助辅助栈，输出找到的节点的路径（从根节点到该节点）*/
void OutputNodePath(PNODE pNode)
{
char stack[24];
int top = 0;
PNODE pCur = pNode;
while(pCur->parent != NULL)
{
stack[top++] = pCur->num;
pCur = pCur->parent;
}
while(top > 0)
{
printf("%d", stack[ top - 1 ]);
--top;
}
printf("\n");
}

int main(int argc, char* argv[])
{
int depth, step;
char path[24];
PNODE pRoot, pStart, pDest;
while(scanf("%d %d\n", &depth, &step) != EOF)
{
gets(path);
pRoot = CreateTree(depth);
pStart = GetNodeByPath(pRoot, path);
pDest = GetNodeBySteps(pRoot, pStart, step);
OutputNodePath(pDest);
FreeTree(pRoot);
}
return 0;
}

【分析】为什么算法（2）比算法（1）快？

算法（1）永远是一个一个数字向前数，步进值（step）永远为 1 ; 当初我想改进算法（1）时发现，如果不借助数据结构，很难在原基础上进行改进。集合中的数也很难用数学公式计算或总结（这也是采用模拟法的原因）。

算法（2）是在树中导航，注意树节点越往上（深度越小），节点的 sum 值越大（而且是随着深度减小，以极快的指数速度增长），所以算法（2）的数数方式是跳跃式的，而且能用很快速度探索到一个理想的 Step 值（该 Step 足够大，又满足 Step <= K ，即向目标迈进的步子足够大，而又不会超越目标节点），该 Step 由树节点的 sum 值表示，然后直接越过该子树所代表的子集合，无需遍历该子集合（所有数字或树节点）。因此访问的节点在树中的深度越浅（越靠近树根），则以该节点为根的子树的规模就越大，代表着跨越的数字个数就越多。由于每个节点最多只有两个哥哥节点，在同一深度向前移动时所消耗的时间不多，因此算法能以很快的速度上升到跨度尽可能大的可访问节点。因此算法（2）在时间上比算法（1）高效的多。

算法（2）的另一种形象理解是：

B > A，则水平方向 B 位于 A 子树的下方或 A 的右侧子树。则存在一个深度最大（设深度为 d ）的公共子树 T ，满足 A, B ∈ T 。

现在从节点 B 出发，寻找节点 A。由于 A 比 B 小，因此 B 不可能是 T 的根。

(a). 如果 A 不是 T 的根，则必然 A 和 B 分别位于 T 的左右两个子树。因此从 B 所在的右侧子树上浮到（d+1）深度后，继续向前移动到 A 所在的左侧子树，然后靠右侧下沉到 A 。（搜寻路线类似梯形）

(b). 如果 A 是 T 的根，则靠左上浮到 A 。

上诉两种情况，在水平方向上在各个深度上都可能呈现一些向左的水平步进。因此在 向前向上探寻时，探寻路径呈“锯齿形”。向下探寻时则是“直线”式下降。对平均情况，探索路径的长度（时间）和树的高度 N 为线性关系。

Figure 1. 节点 B 到节点 A 的探寻路径；

如 Figure 1 所示。图中红色虚线箭头相连得到的路径，即为从 B 到 A 的探寻路径。图中 A 和 B 的最深公共子树 T 是数字“10”所在节点，同时 T 被用粗线表示。灰色节点为可访问节点，斜线表示的节点为位于搜索路线上，但是被经过（Pass）的节点。图中 N = K = 4；从 A 到 B 的序列是：{ 1021, 1023, 103, 1030, 1031 } ;

【缺陷】但算法（2）的结果是内存超出限制（MLE）。理由实际上同（1），当 N 很大时，树非常庞大。由于它是一个满三叉树，所以节点数量是一个等比数列的和：

Sum = ∑ ( 3 ^ i ) = 1 + 3 + 9 + 27 + ... + 3^N = ( 3 ^ ( N + 1) - 1 ) / 2 ;

----( 高度为 N + 1 的三叉树的所有节点数量 ) ;

从上式粗略估算可知内存需求极大，产生 MLE 也就不足为奇了，考虑极限情况：

假设 N = 19，则此树共含有 1,743,392,200 个节点。设每个节点占用 24 Bytes 则：在内存中建立该树需要：38.97 GB ！！！ @_@ ...

（1）和（2）的解法一个超时一个超内存限制，都是因为该集合的元素数量非常大导致的。既要利用（2）中的三叉树模型的时间效率，但又不能采用在内存中完整建立树的方法，因此导出下面的第三个解法。

（3）正确解：虚拟树 / 树枝法（Result：AC）

为了时间效率，依然采用三叉树的模型，但是不能在内存中完整建树，因此启发我们，可以在内存中仅仅保留一条树枝，该树枝最长的长度（叶子在树中所处的深度）为 N。考察解法（2）中的方法，无非是在树之间进行导航，即从某个节点到其父节点，左侧的哥哥节点，右下方的幼子节点。同时，由于此树满足，相同深度的所有节点的 sum 值相同。因此我们可以仅用一条树枝即完成（2）中的算法。

方法是：在内存中不建立整个树，而是仅仅存储一个当前树枝。树枝长度可伸缩，最大为N。树枝采用一个线性表结构保存，可以使用数组或链表（为了代码简便我们使用数组）。每个节点依然含有两个属性： num 和 sum。如果说算法（2）中的树是内存中的实际树（物理树），则算法（3）中的树是仅存在于思维模型中的“虚拟树”。

一个树枝在树中的位置，以及它在数组中的存储状态如下图所示，图中树枝部分用实体粗线条表示，整个树由于不在内存中，因此用虚线表示：

为了实现算法，我们必须很容易的确定该树枝在完整的树模型中的位置和形态。即容易实现以下问题：

（3.1）求出某个节点在同辈兄弟中的排行索引（ Index_In_Siblings ），∈ { 0，1，2 } ;

（3.2）求出某个节点的哥哥节点（左侧）的 num （ Num_Of_Elder_Brother ），∈ { 0，1，2，3 } ;

（3.3）求出某个节点的幼子节点（右下）的 num （ Num_Of_Right_Child ），∈ { 0，1，2，3 } ;

其中（3.1）和（3.2）可以通过本节点的 num 和其父节点的 num 推断得出。（3.3）可以从本节点的 num 求出。

算法执行过程中，随着游标在树中的节点之间移动，树枝在树中的伸展形态（在树中的位置和树枝的长度）也同时发生变化，当寻找到目标节点 A 以后，树枝静止在最终状态，根据方法返回的树枝长度即可确定最终的树枝。目标节点 A 即为最终树枝的末端叶子节点。

因此解法（3）三叉树树枝法算法与（2）相同，但解决了空间复杂度的问题，代码如下： ( √. 以下代码是可接受的 )

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

typedef struct _NODE
{
int num; /* 节点数字, 取值 0,1,2,3 */
int sum; /* 1 + 3 + 9 + ... + 3^k */
} NODE, *PNODE;

NODE nodes[20]; //树枝

//初始化树枝各个节点的 sum 值
void InitSums(int N)
{
int i;
//叶子节点
nodes[N-1].sum = 1;
for(i = N - 2; i >=0 ; --i)
{
nodes[i].sum = nodes[i + 1].sum * 3 + 1;
}
}

//初始化树枝各个节点的 num 值
//path: "1231"

int InitNodesByPath(char *path)
{
int depth = 0;
char *p = path;
while(*p)
{
nodes[depth].num = (*p - '0');
++depth;
++p;
}
return depth - 1;
}

//输出指定深度节点的路径（从根节点到该节点）
void OutputNodePath(int depth)
{
int i;
for(i = 0; i <= depth; i++)
{
printf("%d", nodes[i].num);
}
printf("\n");
}

//获取节点在兄弟节点中的排行索引
int GetIndexInSibling(int depth)
{
if(depth == 0)
return (nodes[depth].num - 1);
else if(nodes[depth-1].num > nodes[depth].num)
{
return nodes[depth].num;
}
else
{
return nodes[depth].num - 1;
}
}

//返回哥哥节点的数字
int GetBrother(int depth)
{
int result = nodes[depth].num - 1;
if(depth > 0 && nodes[depth-1].num == result)
{
--result;
}
return result;
}

//返回幼子的数字
int GetRightChild(int depth)
{
int result = 3;
if(nodes[depth].num == 3)
result = 2;
return result;
}

//从节点A开始向前追溯到节点B，返回对应深度
//nStart: 节点A的深度
//step：节点A和B之间的距离

int GetNodeBySteps(int nStart, int nStep)
{
int remainStep = nStep;
int depth = nStart;

while(remainStep > 0)
{
//回退到父节点
if(GetIndexInSibling(depth) == 0)
{
//向上返回一层时，只-1
depth--;
remainStep--;
continue;
}
//进入哥哥节点
nodes[depth].num = GetBrother(depth);
while(nodes[depth].sum > remainStep)
{
//向下进入最右侧的最小子节点分支
nodes[depth + 1].num = GetRightChild(depth);
depth++;
}
remainStep -= nodes[depth].sum;
}
return depth;
}

int main(int argc, char* argv[])
{
int N, K;
char path[24];
int nStart, nDest;

while(scanf("%d %d\n", &N, &K) != EOF)
{
gets(path);
InitSums(N);
nStart = InitNodesByPath(path);
nDest = GetNodeBySteps(nStart, K);
OutputNodePath(nDest);
}
return 0;
}

以上代码提交后的结果是 AC。运行消耗是时间 120 ms，空间 180 KB。空间需求微不足道可以说是O（1），但用时是解排行榜单上的其他 C++ 优秀解法用时（40ms ~ 60ms）的两三倍。一可能是我用了很多很小的函数，没有inline，多少带来一些函数调用的开销，二是可能别人的算法要比我更快更好。

【分析】为什么可以使用树枝的方法？

此题目中，树的规模非常大，所以逼迫我们使用了树枝法，那么为什么可以不在内存中建立树呢，这是因为树自身具有的内在规律，即节点不是完全随机和独立的，而是存在下面的关系，假设树根深度为 1，树的高度（叶子节点的深度）为（N + 1），则深度为 d 的节点：Node.sum = ( 3 ^ (N + 2 - d ) - 1 ) / 2; 对于非叶子节点，有三个子节点，按升序排列并与父节点不重复。因为有了这些已知条件，使我们能推断出我们需要的节点的信息，因此不需要一个完整的树来存储它。

【说明】本文所有插图，使用 Microsoft Office Visio 绘制。

本文链接

ZOL 简单题集合（二）

2011-11-08T19:59:00Z

对以下简单题，我同时给出一个我主观认为的难度值（0.1~1.0之间）。

(1). ZOL1072: Microprocessor Simulation. (Difficulty: 0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1072

微处理器模拟，它含有两个累加器，代码和内存统一寻址，即冯诺依曼结构，比较简单。

#include <stdio.h>
#include <string.h>

char mem[256]; /* 256 words 内存 */
char A; /* A 累加器 */
char B; /* B 累加器 */

int PC; /*程序计数器，code取址用*/

void Run()
{
int flag_STOP = 0;
int code, addr;
char tmp;
PC = 0;

do
{
/* reset PC */
if(PC >= 0xF0)
break;

/* 取指令 */
code = mem[PC];
++PC;

switch(code)
{
/* LD: Load accumulator A with the contents of memory
at the specified argument.*/
case 0:
addr = mem[PC] * 16 + mem[PC+1];
PC += 2;
A = mem[addr];
break;

/* ST: Write the contents of accumulator A to the memory
location specified by the argument.*/
case 1:
addr = mem[PC] * 16 + mem[PC+1];
PC += 2;
mem[addr] = A;
break;

/* SWP: Swap the contents of accumulators A and B. */
case 2:
tmp = A;
A = B;
B = tmp;
break;

/* ADD: Add the contents of accumulators A and B. The
low word of the sum is stored in A, and the high
word in B. */
case 3:
tmp = A + B;
A = (tmp & 0x0F);
B = (tmp >> 4);
break;

/* INC: Increment accumulator A. Overflow is allowed;
that is, incrementing F yields 0. */
case 4:
if(A == 0x0F) A = 0;
else A++;
break;

/* DEC: Decrement accumulator A. Underflow is allowed;
that is, decrementing 0 yields F.*/
case 5:
if(A == 0) A = 0x0F;
else A--;
break;

/* BZ: If accumulator A is zero, the next command to be
executed is at the location specified by the argument.
If A is not zero, the argument is ignored and nothing
happens. */
case 6:
addr = mem[PC] * 16 + mem[PC+1];
PC += 2;
if(A == 0)
{
PC = addr;
}
break;

/* BR: The next command to be executed is at the location
specified by the argument. */
case 7:
addr = mem[PC] * 16 + mem[PC+1];
PC = addr;
break;

/* STP: Stop execution of the program. */
case 8:
flag_STOP = 1;
break;
}
}
while(!flag_STOP);
}

char CharToNum(char c)
{
if(c >= '0' && c <= '9') return (c - '0');
else return (c - 'A' + 10);
}

char NumToChar(char c)
{
if(c >= 0 && c <= 9) return (c + '0');
else return (c + 'A' - 10);
}

int main(int argc, char* argv[])
{
char line[264];
int i, j;

do
{
/* 读取一次完整的输入 */
i = 0;
do
{
gets(line);
for(j = 0; j < strlen(line); j++)
{
mem[i] = CharToNum(line[j]);
i++;
}
}
while(i < 256);

/*结束输入的标志*/
if(mem[0] == 8)
break;

Run();

/* output */
for(j = 0; j < 256; j++)
{
printf("%c", NumToChar(mem[j]));
}
printf("\n");
}
while(1);
return 0;
}

(2). ZOL1414: Num Steps. (Difficulty: 0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1414

一个网格如下图所示，给出一个坐标（x，y），要求输出其数字，如果没有数字则输出 "No Number”;

#include <stdio.h>
int main(int argc, char* argv[])
{
int count, i;
int x, y, num;
scanf("%d", &count);
for(i = 0; i < count; i++)
{
scanf("%d %d", &x, &y);
if(x - y == 0 || x - y == 2)
{
num = ((x >> 1) << 2) + (x & 1) - (x - y);
printf("%d\n", num);
}
else
printf("No Number\n");
}
return 0;
}

(3). ZOL1170: String Matching. (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1170

求出两个字符串的相似值（一个化简后的分数）。

#include <stdio.h>
#include <string.h>

char szLine[512];

//得到两个字符串的相同字符个数
int SameLetterCount(const char* s1, const char* s2)
{
int count = 0;
const char *p1 = s1;
const char *p2 = s2;
while(*p1 && *p2)
{
if(*p1 == *p2) count++;
++p1;
++p2;
}
return count;
}

//此方法的时间复杂度应该是O(n ^ 2)
void GetAppx(const char* s1, const char* s2, int* pAppx, int* pTotalLen)
{
int appx = 0, tmp_appx = 0, index;

int len1 = strlen(s1);
int len2 = strlen(s2);

*pTotalLen = len1 + len2;

if(strcmp(s1, s2) == 0)
{
*pAppx = *pTotalLen;
return;
}

for(index = -(len2 - 1); index <= len1 - 1; ++index)
{
if(index <= 0)
tmp_appx = SameLetterCount(s1, s2 - index);
else
tmp_appx = SameLetterCount(s2, s1 + index);

if(tmp_appx > appx)
appx = tmp_appx;
}
*pAppx = appx * 2;
}

// 辗转相除法，求最大公约数
int GetGcd(int a, int b)
{
int tmp;
while(b > 0)
{
tmp = a % b;
a = b;
b = tmp;
}
return a;
}

int main(int argc, char* argv[])
{
char* pBlank = NULL;
int totalLen = 0, appx = 0, gcd = 0;
while( 1 )
{
gets(szLine);
if(strcmp(szLine, "-1") == 0)
break;

//在空格处截断字符串
pBlank = strchr(szLine, ' ');
*pBlank = 0;

GetAppx(szLine, pBlank + 1, &appx, &totalLen);

if(appx == 0)
printf("appx(%s,%s) = 0\n", szLine, pBlank + 1);
else if(appx == totalLen)
printf("appx(%s,%s) = 1\n", szLine, pBlank + 1);
else
{
//化简分数
gcd = GetGcd(totalLen, appx);
totalLen /= gcd;
appx /= gcd;

printf("appx(%s,%s) = %d/%d\n",
szLine, pBlank + 1, appx, totalLen);
}
}
return 0;
}

(4). ZOL1240: IBM Minus One (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1240

超级简单，把字符串中每个字符用其字母序后面的字符替换。

#include <stdio.h>
#include <string.h>

//把每个字母向后旋转一格，c = c + 1, Z->A
void Transfer(char* s)
{
char* p = s;
while(*p)
{
if(*p == 'Z') *p = 'A';
else *p = *p + 1;
++p;
}
}

int main(int argc, char* argv[])
{
char line[56];
int count = 0, i;

scanf("%d\n", &count);
for(i = 0; i < count; i++)
{
gets(line);
Transfer(line);
printf("String #%d\n%s\n\n", i+1, line);
}
return 0;
}

(5) ZOL1295: Reverse Text (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1295

反转字符串，即 CRT 中的 strrev。

#include <string.h>
#include <stdio.h>

void reverse(char* str)
{
char tmp;
int left = 0;
int right = strlen(str) - 1;
while(left < right)
{
tmp = str[left];
str[left] = str[right];
str[right] = tmp;
++left;
--right;
}
}

int main(int argc, char* argv[])
{
char str[256];
int n, i;
scanf("%d\n", &n);
for(i=0; i<n; i++)
{
gets(str);
/*scanf("%s", str);*/
reverse(str);
printf("%s\n", str);
}
return 0;
}

(6). ZOL1383: Binary Numbers (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1383

输出一个数字二进制表示中 1 所在的位。（注意输出格式）

#include <stdio.h>

int main(int argc, char* argv[])
{
int count = 0, i, num, iDigit;
//是否需要在该位前输出一个空格
int bNeedSpace;

scanf("%d", &count);
for(i = 0; i < count; i++)
{
scanf("%d", &num);
iDigit = 0;
bNeedSpace = 0;
while(num != 0)
{
if(num & 1)
{
if(bNeedSpace) printf(" ");
printf("%d", iDigit);
bNeedSpace = 1;
}
num = (num >> 1);
++iDigit;
}
if(i < count - 1)
printf("\n");
}
return 0;
}

(7). ZOL1814: Candy Sharing Game (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1814

分糖果游戏，学生围成一圈，每次把手里的一半糖果分给右侧的人，如果任何人糖果为奇数，则再分给他一颗，直到所有人持有糖果数相同。模拟法。

#include <stdio.h>

//students: 每个学生持有的糖果数（逆时针方向）
//n: 学生个数
//rounds：游戏轮次
//candy：游戏结束时每个学生手里的糖果数
void Play(int* students, int n, int* rounds, int* candy)
{
int i, students0, tmp_candy, left_candy;
int bGameOver;
*rounds = 0;
while(1)
{
students0 = students[0];
bGameOver = 1;
for(i = 0; i < n; i++)
{
left_candy = (i == (n-1))? students0 : students[i+1];
students[i] = (students[i] + left_candy)/2;
//如果是奇数，立即再给他一个糖果
if(students[i] & 1)
students[i]++;

if(i == 0)
tmp_candy = students[0]; //初始化
else if(bGameOver && students[i] != tmp_candy)
{
bGameOver = 0;
}
}
(*rounds)++;
if(bGameOver) break;
}

//最终结果
*candy = students[0];
}

int main(int argc, char* argv[])
{
int students[1024];
int n, i;
int rounds, candy;

while(1)
{
scanf("%d", &n);
if(n == 0) break;
for(i=0; i<n; i++)
scanf("%d", (students + i));

Play(students, n, &rounds, &candy);
printf("%d %d\n", rounds, candy);
}
return 0;
}

(8). ZOL2680: Clock (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2680
给出 5 个时刻，按时钟的时针，分针夹角从小到大排序，输出中间的时刻。显然，整数分钟（不考虑秒）时刻，时针分针的夹角是 0.5 角度的整数倍，因此为回避浮点数，采用 0.5 度为指针夹角的基本单位（一个圆周为 360 度）。由于需要输出的只是排序后的中间元素，排序时只要排好一半即可。

#include <stdio.h>

typedef struct tagTime
{
int angle; //夹角以0.5度为单位
int hour;
int minute;
} TIME;

typedef TIME Item;

Item items[5];

int lessthan(Item t1, Item t2)
{
if (t1.angle < t2.angle) return 1;
else if(t1.angle > t2.angle) return 0;
else if(t1.hour < t2.hour) return 1;
else if(t1.hour > t2.hour) return 0;
else if(t1.minute < t2.minute) return 1;
else return 0;
}

/*交换a[]的i，j项*/
void exchange(Item a[], int i, int j)
{
int _angle = a[i].angle;
int _hour = a[i].hour;
int _minute = a[i].minute;

a[i].angle = a[j].angle;
a[i].hour = a[j].hour;
a[i].minute = a[j].minute;

a[j].angle = _angle;
a[j].hour = _hour;
a[j].minute = _minute;
}

/*选择排序*/
// stopIndex: 当排序到索引stopIndex，即可停止排序
void SelectionSort(Item a[], int left, int right, int stopIndex)
{
int i, j, min;
//for(i = left; i < right; i++) //完整排序
for(i = left; i <= stopIndex; i++)
{
min = i;
for(j = i + 1; j <= right; j++)
if(lessthan(a[j], a[min])) min = j;
exchange(a, i, min);
}
}

//以 0.5度为单位（eg. 180 units = 90 度，720 units = 360 度）
int GetAngle(int hour, int minute)
{
int hour2 = (hour > 12) ? (hour - 12) : hour;
int a1 = 60 * hour2 + minute;
int a2 = minute * 12;
int result = a2 - a1;
if(result < 0)
result = -result;
if(result > 360)
result = 720 - result;
return result;
}

int main(int argc, char* argv[])
{
int i, j, count;
char line[48];
scanf("%d\n", &count);
for(i = 0; i < count; i++)
{
gets(line);
for(j = 0; j < 5; j++)
{
items[j].hour = ( line[j*6] - '0' ) * 10
+ ( line[j*6+1] - '0' );
items[j].minute = ( line[j*6 + 3] - '0' ) * 10
+ ( line[j*6+4] - '0' );
items[j].angle = GetAngle(items[j].hour, items[j].minute);
}
SelectionSort(items, 0, 4, 2);
printf("%02d:%02d\n", items[2].hour, items[2].minute);
}
return 0;
}

(9). ZOL3191: Strange Clock (0.2)
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3191

给出时针的角度，输出该时刻处于几点钟。

#include <stdio.h>

int main(int argc, char* argv[])
{
int hourBig, hourSmall;
int bExactly; //注意 gcc 没有定义过 bool 类型
int degree;

while( 1 )
{
scanf("%d", &degree);
if(degree == -1) break;

bExactly = (degree - (degree / 30 * 30) == 0);
hourBig = (degree < 120 ? 3 : 15) - (degree / 30);
hourSmall = (hourBig == 0) ? 11 : (hourBig - 1);

if(bExactly)
printf("Exactly %d o'clock\n", hourBig);
else
printf("Between %d o'clock and %d o'clock\n", hourSmall, hourBig);
}
return 0;
}

(10). ZOL3247: Hello World (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3247

给出一个点阵，要求输出字符图形（每一行输入由 5 个字节组成，代表一个字符，每个字节代表该字符的一列，即每个字符实际上7 * 5 像素，注意行和 bit 之间的对应关系，低位对应的是上方像素，高位对应下方像素，所有字节的最高位为 0，表示最后一行没有任何像素，注意最后一行不能输出一长串空格，而是要输出成空行即直接换行，否则将导致 PE），备注：可使用 strtol 把16进制字符串转换成整数。

#include <stdio.h>

char map[80][5];

char CharToInt(char c)
{
if(c >= '0' && c <= '9')
return (c - '0');
else if(c >= 'A' && c <= 'F')
return (c + 10 - 'A');
else
return 0;
}

int main(int argc, char* argv[])
{
char line[24];
int test_count, char_count, i, j, k, col;
scanf("%d", &test_count);
for(i = 1; i <= test_count; i++)
{
scanf("%d\n", &char_count);
for(j = 0; j < char_count; j++)
{
gets(line);
for(k = 0; k < 5; k++)
{
map[j][k] = CharToInt( line[k*3] ) * 16
+ CharToInt( line[k*3+1] );
}
}

//output the string
printf("Case %d:\n\n", i);

//j: rows index
for(j = 0; j < 8; j++)
{
if(j < 7)
{
for(k = 0; k < char_count; k++)
{
//输出一个字符的某一行（五列）
for(col = 0; col < 5; col++)
{
if( map[k][col] & (1 << j) )
printf("#");
else
printf(" ");
}
//字符和字符之间的空列
if(k < char_count - 1)
printf(" ");
}
}
//一行结束，换行
printf("\n");
}
}
return 0;
}

(11). ZOL3322: Who is older ? (0.1)
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3322

给出两个人的生日，比较年龄谁大，超级简单，直接比较字符串即可。

#include <stdio.h>
#include <string.h>

int main(int argc, char* argv[])
{
char line[36];
int n, i, result;
scanf("%d\n", &n);
for(i = 0; i < n; i++)
{
gets(line);
line[10] = 0;
result = strcmp(line, line + 11);
if(result < 0)
printf("javaman\n");
else if(result > 0)
printf("cpcs\n");
else
printf("same\n");
}
return 0;
}

(12). ZOL3487: Ordinal Numbers (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3487

给出一个数字，根据规则，给出其序数后缀表示。

#include <stdio.h>
#include <string.h>

void GetPostfix(const char* line, char* postfix)
{
int len = strlen(line);
//十位上的字符
char c = '0';
if(len > 1)
c = line[len-2];

//If the tens digit of a number is 1, then write
//"th" after the number. For example: 13th, 19th, 112th, 9311th.
if(c == '1')
{
strcpy(postfix, "th");
}
else
{
//If the tens digit is not equal to 1, then use
//"st" if the units digit is 1,
//"nd" if the units digit is 2,
//"rd" if the units digit is 3, and
//"th" otherwise:
//For example: 2nd, 7th, 20th, 23rd, 52nd, 135th, 301st.

switch(line[len-1])
{
case '1': strcpy(postfix, "st"); break;
case '2': strcpy(postfix, "nd"); break;
case '3': strcpy(postfix, "rd"); break;
default: strcpy(postfix, "th"); break;
}
}
}

int main(int argc, char* argv[])
{
int count = 0, i;
char line[48], postfix[4];

scanf("%d\n", &count);
for(i = 0; i < count; i++)
{
gets(line);
GetPostfix(line, postfix);
printf("%s%s\n", line, postfix);
}
return 0;
}

(13). ZOL3542: Hexadecimal View (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3542

给出一行字符串（全部是可打印字符），输出 16 进制视图。备注：字符大小写的互相转换也可使用 touppder / tolower 。

#include <stdio.h>
#include <string.h>

void OutputHexView(char* s)
{
char *p = s;
int i, linenum = 0;
char line[16];
int len = strlen(s);
int linecount = (len + 15)/16; //需要打印的总行数
for(linenum = 0; linenum < linecount; ++linenum)
{
memset(line, 0, 16);
strncpy(line, p, 16);
p += 16;
printf("%04x: ", (linenum << 4) & 0xffff);
for(i = 0; i < 16; i++)
{
if(line[i] == 0)
printf(" "); //没有字符（最后一行的 padding 部分）
else
printf("%02x", line[i]);

if(i & 1)
printf(" "); //每两个字符之间有一个空格间隔
}
for(i = 0; i < 16; i++)
{
if(line[i] == 0)
{
break;
}
else if(line[i] >= 'a' && line[i] <= 'z') // islower( line[i] )
{
printf("%c", line[i] + 'A' - 'a'); // toupper( line[i] )
}
else if(line[i] >= 'A' && line[i] <= 'Z')
{
printf("%c", line[i] + 'a' - 'A'); // tolower;
}
else
{
printf("%c", line[i]);
}
}
printf("\n");
}
}

int main(int argc, char* argv[])
{
char line[4100];
while( gets(line) != NULL )
{
OutputHexView(line);
}
return 0;
}

(14). ZOL3317: Murder in Restaurant (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3317

给出一个旅馆的入住信息表，客人数和房间数，给出每个客人的试图入住日期和离店日期（都用整数表示），尝试给客人分配一个最小房号（从1开始计数）的房间，要求输出每个客人的入住房号，如果该客人来时没有房间则输出 0。

解法：把客人按照入住时间升序排序，然后依次分配房间号。（有些类似贪心法中的申请会议室）

#include <stdio.h>

int Rooms_Leave[100]; /* 每个元素表示第 i 个房间退房的日期 */
int Renters_RoomNo[100]; /* 每个元素分配给第 i 个客人的房间号 */

typedef struct tagRENTER
{
int index; //客人索引（0 base）
int EnterDate; //入住日期
int LeaveDate; //离店日期
} RENTER, *PRENTER;

typedef RENTER Item;

Item items[100];

int less_than(Item t1, Item t2)
{
if (t1.EnterDate < t2.EnterDate) return 1;
else return 0;
}

/*交换a[]的i，j项*/
void exchange(Item a[], int i, int j)
{
if(i != j)
{
int _index = a[i].index;
int _EnterDate = a[i].EnterDate;
int _LeaveDate = a[i].LeaveDate;

a[i].index = a[j].index;
a[i].EnterDate = a[j].EnterDate;
a[i].LeaveDate = a[j].LeaveDate;

a[j].index = _index;
a[j].EnterDate = _EnterDate;
a[j].LeaveDate = _LeaveDate;
}
}

/*选择排序*/
void SelectionSort(Item a[], int left, int right)
{
int i, j, min;
for(i = left; i < right; i++)
{
min = i;
for(j = i + 1; j <= right; j++)
if(less_than(a[j], a[min])) min = j;
exchange(a, i, min);
}
}

int main(int argc, char* argv[])
{
int renter_count, room_count, i, j;

while( 1 )
{
scanf("%d %d", &renter_count, &room_count);

if(renter_count == 0)
break;

for(i = 0; i < renter_count; i++)
{
Rooms_Leave[i] = 0;
Renters_RoomNo[i] = 0;
items[i].index = i;
scanf("%d %d", &items[i].EnterDate, &items[i].LeaveDate);
}

/* 给每个客人分配房间 */
SelectionSort(items, 0, renter_count - 1);
for(i = 0; i < renter_count; i++)
{
for(j = 0; j < room_count; j++)
{
if(Rooms_Leave[j] <= items[i].EnterDate)
{
Rooms_Leave[j] = items[i].LeaveDate;
Renters_RoomNo[ items[i].index ] = j + 1;
break;
}
}
}

/* output result */
for(i = 0; i < renter_count; i++)
{
printf("%d\n", Renters_RoomNo[i]);
}
}
return 0;
}

(15). ZOL2850: Beautiful Meadow ( 0.1 )

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2850

给出一个 N * M 的网格，每个 cell 的值是 0 或 1。如果所有 cell 都是1，或有任何为 0 的 cell 相邻（即共享某条边），则输出No，否则输出Yes。

#include <stdio.h>

int main(int argc, char* argv[])
{
int row, col, i, j, tmp, sum;
int bMowedAdjacent;
char map[100][100];
while(1)
{
scanf("%d %d", &row, &col);
if(row == 0)
break;

bMowedAdjacent = 0;
sum = 0;
for(i = 0; i < row; i++)
{
for(j = 0; j < col; j++)
{
scanf("%d", &tmp);
map[i][j] = tmp;
if(tmp == 0)
{
if(j > 0 && map[i][j-1] == 0)
bMowedAdjacent = 1;
else if(i > 0 && map[i-1][j] == 0)
bMowedAdjacent = 1;
}
else
sum += tmp;
}
}
if(bMowedAdjacent || sum == row * col) printf("No\n");
else printf("Yes\n");
}
return 0;
}

(16). ZOL1094: Matrix Chain Multiplication ( 0.3 )

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1094

虽然题目是算法经典命题-矩阵乘法链，但是此题目考察的绝不是动态规划（DP），而是给出一个矩阵乘法加括号的表达式，求该方案所需的乘法运算数。如果矩阵乘法不相容，则输出 "error"。此题目的输入非常标准，无需考虑表达式的括号不匹配等问题。也无需考虑例如 "ABC" 这种没有加括号的表达式（输入一定给出的是 "((AB)C)" ）。如果是只有单个矩阵，则一定没有括号。这种输入的标准化使我们无需检测特殊情况（例如 "(A)", "ABC", ")AB" 等），可以仅仅用表达式中的括号去推动表达式的解析。

解法是：准备两个辅助栈，一个装入矩阵信息（操作数），一个装入括号（由于输入表达式一定括号匹配，因此第二个辅助栈实际上不需要，但为了保持逻辑完整性依然保留），每次遇到“）”符号，则从操作数栈中弹出两个矩阵，如果相容，则累加这两个矩阵相乘的代价，然后把结果信息 (row, col) 再次入栈。

#include <stdio.h>

typedef struct _tagMatrixInfo
{
int row;
int col;
} MatrixInfo;

MatrixInfo matrix[26];

/* szExpression: 形如"(A(BC))"; 返回值：乘法次数，-1 代表不相容 */
int GetResult(char* szExpression)
{
char *p = szExpression;
char c;

char brackets[512]; /* 括号的栈 */
int pBrackets = -1; /* 栈顶指针 */

MatrixInfo nums[512]; /* 操作数栈 */
int pNums = -1; /* 栈顶指针 */

int row0, col0, row1, col1;
int count = 0; /* 返回的结果：总乘法次数 */
while(*p)
{
c = *p;
++p;
if(c >= 'A' && c <= 'Z') /* push in stack */
{
++pNums;
nums[pNums].row = matrix[c-'A'].row;
nums[pNums].col = matrix[c-'A'].col;
}
else if(c == '(')
{
brackets[++pBrackets] = c;
}
else if(c == ')')
{
/* 从栈中弹出两个操作数 */
row0 = nums[pNums - 1].row;
col0 = nums[pNums - 1].col;
row1 = nums[pNums].row;
col1 = nums[pNums].col;
pNums -= 2;
pBrackets--; /* 弹出一个'(' */

/* 两个操作数是否相容？ */
if(col0 != row1)
return -1;

count += row0 * col0 * col1;

/* 结果信息 push 到操作数栈中 */
++pNums;
nums[pNums].row = row0;
nums[pNums].col = col1;
}
}
return count;
}
int main(int argc, char* argv[])
{
int n, i, result;
char cNum, line[1024];
scanf("%d\n", &n);
for(i = 0; i < n; i++)
{
scanf("%c ", &cNum);
scanf("%d %d\n", &matrix[cNum-'A'].row, &matrix[cNum-'A'].col);
}
while(gets(line) != NULL)
{
result = GetResult(line);
if(result < 0) printf("error\n");
else printf("%d\n", result);
}
return 0;
}

本文链接

ZOL1010（Area）解题报告

2011-11-04T13:17:00Z

ZOL 1010. Area.

题目地址：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1010

基本题意：此题目给出 n 个点的坐标 (xi，yi ) ，要求求出这些点按顺序围成的多边形的面积。同时要求检测出不合法的多边形（例如非相邻边彼此相交的情况）。

此题求面积不难，样例很容易就过了，但是提交 10+ 次基本都是 WA ，几乎失去信心。做题最郁闷的就是你不知道问题到底出在什么地方，可能改了很多次都没有试对地方。后来跑到 88 的算法版搜了下，看到别人的代码，然后事后总结实际还是卡在了什么样的多边形是 Impossible 的，这个检测代码没有写好，耐心不够导致。

（1）求面积很简单，类似求某个曲线的区间积分

用所有多边形的边和X轴围成的梯形的面积累加起来就可以了。例如某条边 ( P1 - P2 ) 和在它在 x 轴的投影 ( p1' - P2' ) 所围成的梯形面积是：

S [ p1->p2 ] = 1/2 * ( y1 + y2 ) * ( x2 - x1 ) ;----（I）

这个式子拆开后就是：

S [ p1->p2 ] = 1/2 * ( -x1 * y1 + x2 * y2 - x1 * y2 + x2 * y1 ) ; ---- ( 注：蓝色部分的 xi * yi 累加后被消掉 )

由于每个边都被累加一遍，每个点参与了组成边两次（前一条边的终点和后一条边的起始点），所以每个顶点自身坐标的乘积 ( xi * yi ) 累加的时候都被消掉了！最后就是累加所有的式（I）：

Area = ∑ 1/2 * ( -x( i ) * y( i + 1 ) + x( i + 1 ) * y( i ) ) ;

　　----( i = 1,2,...,n，且P(n+1) = P(0) ); ----（II）

上面的式子，括号内是两个矢量的叉积 P[ i + 1 ] × P[ i ]。因此式II实际上是依次累加相邻点的叉积，最后在除以2。考虑叉积的含义，是以两个矢量为相邻边的平行四边形（由 O(0,0), P1, P2, (P1 + P2) 四个点组成）的面积（在平面坐标中用三角形面积相减可以很容易推导出该含义），因此这个方法的物理意义就非常明显了，我们可以直观的假定原点位于多边形内部，显然依次把相邻点和原点围成的三角形的面积累加起来就是这些点组成的多边形的面积。因此 1/2 ( P[ i + 1 ] X P[ i ] ) 就是三角形 O - P[ i + 1 ] - P[ i ] 的面积（平行四边形面积的一半，O 表示原点）。当然，由于叉积有符号，所以原点位于多边形外部也成立，只是在内部更直观，更容易理解。

备注：我们可以把存储顶点的数组扩充一个元素，然后把 P( n+1 ) 赋值为 P( 0 )，这样我们对上式的循环中就不必对顶点索引使用取模运算（MOD）。我自己写的代码采用的（I）这种计算方法，我参考的代码采用（II）中的计算方法，两者计算量相差不大，但后者不太直观，所以我就稍微解释了下两者本质是相同的。

注意式（I）中的梯形面积是有符号的，和 P1，P2 的点顺序相关( S[ p1->p2 ] = -S[ p2->p1 ] ) ，因此 Area 的符号和顶点顺序有关，所以最后别忘了对计算结果求绝对值。

（2）麻烦在于，什么样的多边形是 Impossible 的

做题的时候肯定我们就会着重考虑这一点。因为不管任何多边形，按照（1）都能算出个面积，但是多边形是否是有效的需要单独判断。设多边形有 n 个顶点和边，则：

2.1） n < 3 时，显然是 Impossible，因为一个点或一个线段不能组成多边形。

2.2） n > 3 时，依次判断每条边和它的所有非相邻边不能相交（包含交点位于某一条线段上的情况），保证这一点即可。

2.3） n = 3 时，是三角形，无须做 2.2 中的检测。如果三角形的三个点共线的话，是不是应该输出 Impossible，我们没有考虑也 AC 了（即我们会对这种情况认为是有效的而输出 0.00），估计 OL平台的测试输入也没有考虑这种情况。

下面我们考虑2.2中的检测：

总的边数为 n，则每条边的非相邻边为（n-3）条，所以检测完所有边的情况类似冒泡排序，以及绘制多边形所有顶点的连接线的金刚石图形，需要耗费O（n^2)的时间复杂度。

相邻边必然是相交于顶点的所以不用检测，即使相邻边向内重叠了，比如连续的三个顶点：（0，0），（0，5），（0，3）这种情况也不必担心，因为在下一条边检测时也会检测出相交情况的。

判断两个线段是否相交属于算法中的计算几何部分，主要原理是如果两个线段相交，则从任何一个线段角度看，另一个线段的两个端点都位于它自己的两侧（该线段以任一端点为原点旋转到经过另一个线段的两个端点的时针方向相反）。两个矢量的相对旋转方向利用矢量叉积求出。

我原来还考虑了浮点数和 0 的比较判断，实际上最后从提交结果发现无需考虑这个问题，直接和 0 比就是了。

（3）对顶点坐标的存储

为了检测多边形是不是Impossible的，就必须要存储所有顶点的坐标。如果不需要判断这个，就不需要任何额外的存储空间。那样就简洁多了。当然那样的话这道题也就毫无任何难度，也失去了对计算几何的考察点。

我看了我参考的解法，我居然没有想到像他开一个维度为1000的数组，ft！我是用了一个链表来存储所有的边。。。。汗。。。（当然应该用STL就可以，我习惯了自己写链表的代码），所以我的代码比我参考的那个人的多好多。。。（他的代码好简短！）

另外，由于我用链表存储的是线段，相当于每个顶点被我存储了两次，所以实际上还是浪费了一倍的堆上内存。另外还要加上链表使用的指针占用的空间。当然优点是动态内存管理相比静态数组在内存的使用上要灵活一些，这就无须多做解释了。

检测边是否相交实际上和那个人的代码的原理基本一致，这部分代码我基本是照着《算法导论》上的伪码直译过来的。

我提交的代码如下：

#include <stdio.h>
#include <stdlib.h>

//#define ZEROVALUE 0.00000000000001

#ifndef __max
#define __max(a,b) (((a) > (b)) ? (a) : (b))
#endif

#ifndef __min
#define __min(a,b) (((a) < (b)) ? (a) : (b))
#endif

typedef struct _LINE
{
double x1;
double y1;
double x2;
double y2;
_LINE* pNext;
} LINE;

//以Pi为原点，从 PiPj 到 PiPk 的方位（返回值的符号表示顺时针 or 逆时针）
double Direction(double xi, double yi, //原点
double xj, double yj, //线段1结束点
double xk, double yk) //线段2结束点
{
return (xk - xi) * (yj - yi) - (xj - xi) * (yk - yi);
}

//如果点 Pk 位于线段 PiPj 所在直线上，则它是否位于该线段内
int OnSegment(double xi, double yi,
double xj, double yj, //线段1结束点
double xk, double yk) //线段2结束点
{
if(xk >= __min(xi, xj) && xk <= __max(xi, xj)
&& yk >= __min(yi, yj) && yk <= __max(yi, yj))
return 1;
else
return 0;
}

//判断两个线段P1P2，P3P4是否相交
int intersect(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
{
double d1 = Direction(x3, y3, x4, y4, x1, y1);
double d2 = Direction(x3, y3, x4, y4, x2, y2);
double d3 = Direction(x1, y1, x2, y2, x3, y3);
double d4 = Direction(x1, y1, x2, y2, x4, y4);

if( ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0))
&& ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0)) )
return 1; //相交

else if(d1 == 0 && OnSegment(x3, y3, x4, y4, x1, y1))
return 1;
else if(d2 == 0 && OnSegment(x3, y3, x4, y4, x2, y2))
return 1;
else if(d3 == 0 && OnSegment(x1, y1, x2, y2, x3, y3))
return 1;
else if(d4 == 0 && OnSegment(x1, y1, x2, y2, x4, y4))
return 1;
else
return 0; //绝对不相交
}

/* 增加线段到链表尾部 */

void AddLine(LINE** ppHead, LINE** ppTail,
double x1, double y1,
double x2, double y2)
{
LINE *pNode = (LINE*)malloc(sizeof(LINE));
pNode->pNext = NULL;
pNode->x1 = x1;
pNode->y1 = y1;
pNode->x2 = x2;
pNode->y2 = y2;

if(*ppTail != NULL)
{
(*ppTail)->pNext = pNode;
}
else
{
*ppHead = pNode;
}
*ppTail = pNode;
}

void FreeList(LINE** ppHead, LINE** ppTail)
{
LINE* pNode = (*ppHead);
while(pNode != NULL)
{
LINE* tmp = pNode->pNext;
free(pNode);
pNode = tmp;
}
*ppHead = NULL;
*ppTail = NULL;
}

/* 检查是否这一系列点围成的多边形是否合法 */

int CheckValid(LINE* pHead)
{
int index = 0; /* 当前正循环到的边的索引 */
LINE* pCur = pHead;
LINE* pTest;

while(pCur != NULL)
{
pTest = NULL;
if(pCur->pNext != NULL)
pTest = pCur->pNext->pNext;

while(pTest != NULL)
{
//最后一条边(n-1) -- (0)，不与第一条边 (0) -- (1) 检测
if(index == 0 && pTest->pNext == NULL)
break;

/* 非相邻边相交？ */
if(intersect(pCur->x1, pCur->y1, pCur->x2, pCur->y2,
pTest->x1, pTest->y1, pTest->x2, pTest->y2))
{
return 0;
}
pTest = pTest->pNext;
}
pCur = pCur->pNext;
++index;
}
return 1;
}

int main(int argc, char* argv[])
{
LINE *pHead = NULL, *pTail = NULL;
int i, n = 0, figure = 1;
double x0, y0, x1, y1, x2, y2;
double area = 0;

//int test = intersect(0, 1, 1, 0, 1, -1, 0, 0.5);

while(1)
{
scanf("%d", &n);
if(n <= 0)
break;

//打印一个空行
if(figure > 1)
printf("\n");

area = 0;
scanf("%lf %lf", &x0, &y0);
x1 = x0;
y1 = y0;
for(i = 1; i <= n; i++)
{
if(i < n)
scanf("%lf %lf", &x2, &y2);
else
{
x2 = x0;
y2 = y0;
}
area += (y1 + y2) * (x2 - x1) * 0.5;

AddLine(&pHead, &pTail, x1, y1, x2, y2);

x1 = x2;
y1 = y2;
}

if(area < 0)
area *= -1;

if(n < 3)
printf("Figure %d: Impossible\n", figure);
else if(!CheckValid(pHead))
printf("Figure %d: Impossible\n", figure);
else
printf("Figure %d: %.02lf\n", figure, area);

FreeList(&pHead, &pTail);

figure++;
}
return 0;
}

另附上我参考的代码：

发信人: dynamic (programming@math), 信区: ACMICPC
标题: Re: 1010里的错误多边形有多少可能性？
发信站: 逸仙时空 Yat-sen Channel (Wed Apr 9 20:55:07 2003), 站内信件

我的程序

//zju 1010
//by dynamic
//on sunday july 28th

#include <stdio.h>

double det(double x1,double y1,double x2,double y2,double x3,double y3)
{
return x1*y2+x2*y3+x3*y1-x2*y1-x3*y2-x1*y3;
}

int main()
{
int n,i,j,count=0,temp;
double x[1000],y[1000],area;
while(1)
{
scanf("%d",&n);
if (n==0) return 0;
count++;
if (count>1) printf("\n");
printf("Figure %d: ",count);
for(i=0;i<n;i++) scanf("%lf%lf",&x[i],&y[i]);
if (n<3){
printf("Impossible\n");
continue;
}
for(i=0;i<n;i++)
for(j=(i+1)/n;j<i-1;j++){
temp=(i+1)%n;
if (det(x[j],y[j],x[i],y[i],x[j+1],y[j+1])*det(x[j],y[j],x[temp],y[temp],x[j+1],y[j+1])<=0&&
det(x[i],y[i],x[j],y[j],x[temp],y[temp])*det(x[i],y[i],x[j+1],y[j+1],x[temp],y[temp])<=0) {
printf("Impossible\n");
goto quit;
}
}
area=0;
for(i=0;i<n;i++){
area+=x[i]*y[(i+1)%n];
area-=y[i]*x[(i+1)%n];
}
if (area<0) area*=-1;
printf("%.2lf\n",area/2);
quit:;
}
}

参考资料：

1. 《算法导论》，第33章（计算几何学）33.1 节（线段的性质）。

本文链接

CASES	起到限制作用的参数	运动组成	最短时间
case 1	d	抛物线	t1*4
case 2	m	抛物线, 水平线(匀速)	t1*4 + t2
case 3	d, a1	抛物线, 斜线(匀加速)	t14 + t32
case 4	m, a1	抛物线, 斜线(匀加速), 水平线(匀速)	t14 + t32 + t2