别摸我｜catch the digital flow » C/C++

Visual Studio 用 debug 启动调试挂起，提示 Visual Studio Is Busy

北极冰仔 — Wed, 11 Aug 2010 03:27:08 +0000

最近遇到了很多件周围人从来没遇到过的事，很是费解。

其中一件就是我的 Visual Studio 以 debug 方式启动调试某个工程，经常会挂起，output 显示正在加载某个 dll 导出的符号，然后就不动了，系统托盘有时会同步提示“Visual Studio is busy”，概率达到 90% 以上，经过再三验证，确实是我的 Visual Studio 出问题了，一开始以为是我之前改过 include/lib/bin 的默认路径，编译依赖和运行依赖与别人不同所致，事实证明不是这个原因。

刚才同样的情况再次发生，终于找到了有价值的线索：

This might be related with symbol server configuration.
Check that valid symbol server path is used, and that network access works
properly. Alternatively, you can try to disable symbol server access completely,
to see if the problem goes away. (Tools | Options | Debugging | etc., as well as
remove _NT_SYMBOL_PATH environment variable if it exists)

猛地想起，之前另外一个项目中，为了跟踪一个 bug，在调试 dump 的时候配置了符号服务器。禁用之，搞定。另外一个诡异的现象也随之消失：同样配置的机器，我启动调试比别人会慢很多。

float 转换 DWORD 的陷阱

北极冰仔 — Tue, 21 Jul 2009 07:14:52 +0000

本以为是个很简单的东西，但其中隐藏了一个很大的陷阱：不能使用强制转换。亲手试试下面的几行代码就知道为什么了：

#include
#include

int main(int argc, char* argv[])
{
float f = 2.0f;
byte content[4];
::ZeroMemory(content, sizeof(content));

memcpy(content, (byte*)&f, 4); // float 原始内容

DWORD dw = (DWORD)f; // C 风格强制转换，错误
memcpy(content, (byte*)&dw, 4);

DWORD dw2 = *(DWORD*)&f; // 转换的正确做法
memcpy(content, (byte*)&dw2, 4);

DWORD dw3 = static_cast(f); // C++ 风格强制转换，错误
memcpy(content, (byte*)&dw3, 4);

return 0;
}

今天一整天全栽在这个上面了。

Google 在 Twitter 上的二进制问候是什么

北极冰仔 — Thu, 09 Apr 2009 02:27:20 +0000

第一眼看到 Google 在 Twitter 上用二进制向人们打招呼的时候，就感觉应该说的是一句话，只是没时间去搞清楚是什么。正好最近实在无聊地厉害，为了避免生命进一步浪费在如此阳光明媚狗熊撒欢的季节，就写了几行代码看看 Google 到底说了什么。

#include
#include
#include
#include

char strchar2char(char buf[]);
void parse(const char* src, char* dst);

int main(int argc, char* argv[])
{
const char* src = "01100110 01100101 01100101 01101100 01101001 01101110 01100111 00100000 01101100 01110101 01100011 01101011 01111001 00001010";
size_t len_dst = (strlen(src) + 1) / 9;

char* dst = (char*)malloc(len_dst + 1);
memset(dst, 0, len_dst + 1);

parse(src, dst);

printf("src: %s\ndst: %s\n", src, dst);

free(dst);

return 0;
}

char strchar2char(char buf[])
{
unsigned char mask = 0x80, ret = 0, i;

for (i = 0; i <8; i++)
{
if ('1' == buf[i])
ret |= mask;

mask>>= 1;
}

return ret;
}

void parse(const char* src, char* dst)
{
char buf[8];
int i;

while (*src)
{
if (' ' == *src)
src++;

for (i = 0; i <8; i++)
buf[i] = src[i];

*dst = strchar2char(buf);

src += 8;
dst++;
}
}

答案揭晓：feeling lucky

DirectX Software Development Kit (November 2008) 下载

北极冰仔 — Fri, 14 Nov 2008 06:13:31 +0000

ORIGIN

http://www.microsoft.com/downloads/details.aspx?FamilyId=5493F76A-6D37-478D-BA17-28B1CCA4865A&displaylang=en

下载地址（直接用迅雷）

DXSDK_Nov08.exe

Brief Description

November 2008
Download the complete DirectX SDK, which contains the DirectX Runtime and all DirectX software required to create DirectX compliant applications.

Quick Details

File Name: DXSDK_Nov08.exe
Version: 9.25.1476
Date Published: 11/7/2008
Language: English
Download Size: 483.2 MB
Estimated Download Time: 19 hr 39 min 56K
Overview
This DirectX SDK release contains updates to tools, utilities, samples, documentation, and runtime debug files for x64 and x86 platforms.

For additional information please see Microsoft DirectX Developer Center along with reviewing the Readme for last-minute updates.

System Requirements

Supported Operating Systems: Windows Home Server; Windows Server 2003; Windows Server 2003 R2 (32-Bit x86); Windows Server 2003 R2 Datacenter Edition (32-Bit x86); Windows Server 2003 R2 Datacenter x64 Edition; Windows Server 2003 R2 Enterprise Edition (32-Bit x86); Windows Server 2003 R2 Enterprise x64 Edition; Windows Server 2003 R2 Standard Edition (32-bit x86); Windows Server 2003 R2 Standard x64 Edition ; Windows Server 2003 R2 x64 editions; Windows Server 2003 Service Pack 1; Windows Server 2003 Service Pack 2; Windows Server 2003 Service Pack 2 x64 Edition; Windows Server 2003 x64 editions; Windows Server 2003, Datacenter Edition (32-bit x86); Windows Server 2003, Datacenter x64 Edition; Windows Server 2003, Enterprise Edition (32-bit x86); Windows Server 2003, Enterprise x64 Edition; Windows Server 2003, Standard Edition (32-bit x86); Windows Server 2003, Standard x64 Edition; Windows Server 2003, Web Edition; Windows Server 2008; Windows Server 2008 Datacenter; Windows Server 2008 Datacenter without Hyper-V; Windows Server 2008 Enterprise; Windows Server 2008 Enterprise without Hyper-V; Windows Server 2008 Standard; Windows Server 2008 Standard without Hyper-V; Windows Small Business Server 2003 ; Windows Small Business Server 2008 Premium; Windows Small Business Server 2008 Standard ; Windows Vista; Windows Vista 64-bit Editions Service Pack 1; Windows Vista Business; Windows Vista Business 64-bit edition; Windows Vista Business N; Windows Vista Enterprise; Windows Vista Enterprise 64-bit edition; Windows Vista Home Basic; Windows Vista Home Basic 64-bit edition; Windows Vista Home Basic N; Windows Vista Home Premium; Windows Vista Home Premium 64-bit edition; Windows Vista Service Pack 1; Windows Vista Starter; Windows Vista Starter N; Windows Vista Ultimate; Windows Vista Ultimate 64-bit edition; Windows Web Server 2008; Windows XP; Windows XP 64-bit; Windows XP Home Edition ; Windows XP Home Edition N; Windows XP Media Center Edition; Windows XP Media Center Edition 2005 Update Rollup 2; Windows XP Professional Edition ; Windows XP Professional N; Windows XP Professional x64 Edition ; Windows XP Service Pack 1; Windows XP Service Pack 2; Windows XP Service Pack 3; Windows XP Starter Edition; Windows XP Tablet PC Edition

Additional Information

This section contains the following:

What's New in the November 2008 DirectX SDK
Known Issues with the November 2008 SDK

What's New in the November 2008 DirectX SDK

This version of the DirectX SDK contains the following new features, tools, and documentation.

PIX for Windows

PIX for Windows supports basic stream capture and single frame capture for Direct3D 11, however the new Direct3D 11 hardware features like tessellation, compute shader, dynamic shader linkage, and new resource formats, are not supported. In addition, advanced features like shader debugging and mesh viewing are not supported. These will be added in a future release.

XACT3 Now Supports the Same xWMA Bitrates Supported by XAudio2

XACT3 now supports the same xWMA bit rates that are supported by XAudio2. The exposed lower bit rates allow titles to take advantage of more aggressive compression.

Updated Audio Sample

The XAudio2 Sound3D sample has been updated to better demonstrate the capabilities of XAudio2 and X3DAudio as well as highlighting best practices.

Direct3D 11 Technical Preview

Included in the November 2008 DirectX SDK is a technical preview of Direct3D 11 and associated components and tools. Direct3D 11 is an update to Direct3D 10.1 enabling new hardware features as well as improving the breadth of configurations supported by Direct3D. As such, Direct3D 11 enables developers to create applications and games that work on Direct3D 10, Direct3D 10.1, and Direct3D 11 hardware when it becomes available. With the addition of WARP and Direct3D 10 Level 9, Direct3D 10.1 and Direct3D 11 have the ability to target fast software rasterization and Direct3D 9 hardware.

This version of the Direct3D 11 technical preview includes support for the following:

Tessellation
Compute Shaders
Multithreaded Rendering
Dynamic Shader Linkage
Windows Advanced Rasterizer (WARP)
Direct3D 10 and Direct3D 11 on Direct3D 9 Hardware (D3D10 Level 9)
Runtime Binaries
D3DX11
Completely Updated HLSL and Direct3D Compiler
D3D11 Reference Rasterizer
D3D11 SDK Layers
In addition, there are four new samples that highlight tessellation, computer shaders, mulithreaded rendering, and dynamic shader linkage.

Tessellation

Direct3D 11 provides additional pipeline stages to support real-time tessellation of high order primitives. With extensively programmable capabilities, this feature allows many different methods for evaluating high-order surfaces, including subdivision surfaces using approximation techniques, Bezier patches, adaptive tessellation, and displacement mapping. This feature will only be available on Direct3D 11-class hardware, so in order to evaluate this feature you will need to use the Reference Rasterizer. For a demo of tessellation in action, check out the SubD11 sample available through the Sample Browser.

Compute Shader

The Compute Shader is an additional stage independent of the Direct3D 11 pipeline that enables general purpose computing on the GPU. In addition to all shader features provided by the unified shader core, the Compute Shader also supports scattered reads and writes to resources through Unordered Access Views, a shared memory pool within a group of executing threads, synchronization primitives, atomic operators, and many other advanced data-parallel features. A variant of the Direct3D 11 Compute Shader has been enabled in this release that can operate on Direct3D 10-class hardware. It is therefore possible to developing Compute Shaders on actual hardware, but an updated driver is required. The full functionality of the Direct3D 11 Compute Shader will is intended for support of Direct3D 11-class hardware, so in order to evaluate the full functionality you will need to use the Reference Rasterizer until such hardware is available. For a demo of the Compute Shader in action, check out the HDRToneMappingCS11 sample available through the Sample Browser.

Multithreaded Rendering

The key API difference from Direct3D 10 in Direct3D 11 is the addition of deferred contexts, which enables scalable execution of Direct3D commands distributed over multiple cores. A Deferred Context captures and assembles actions like state changes and draw submissions that can be executed on the actual device at a later time. By utilizing Deferred Contexts on multiple threads, an application can distribute the CPU overhead needed in the Direct3D11 runtime and the driver to multiple cores, enabling better use of an end-user's machine configuration. This feature is available for use on current Direct3D 10 hardware as well as the reference rasterizer. For a demonstration of API usage, check out the MultithreadedRendering11 sample available through the Sample Browser.

Dynamic Shader Linkage

In order to address the combinatorial explosion problem seen in specializing shaders for performance, Direct3D 11 introduces a limited form of runtime shader linkage that allows for near-optimal shader specialization during execution of an application. This is achieved by specifying the implementations of specific functions in shader code when the shader is assigned to the pipeline, allowing the driver to inline native shader instructions quickly rather than forcing the driver to recompile the intermediate language into native instructions with the new configuration. Shader development is exposed through the introduction of classes and interfaces to HLSL. For a demonstration, check out the Dynamic Shader Linkage 11 sample available through the Sample Browser.

Windows Advanced Rasterizer Platform (WARP)

Available in this SDK through Direct3D 11 and eventually also through Direct3D 10.1, WARP is a fast, multi-core scaling rasterizer that is fully Direct3D 10.1 compliant. Utilizing this technology is as simple as passing the D3D10_DRIVER_TYPE_WARP flag in your device creation.

Direct3D 10 and Direct3D 11 on Direct3D 9 Hardware (D3D10 Level 9)

Available in this SDK through Direct3D 11 and eventually also through Direct3D 10.1, the Direct3D API can target most Direct3D 9 hardware as well as Direct3D 10, Direct3D 10.1 and Direct3D 11 hardware. This is achieved by providing the Feature Level mechanism, which groups hardware into six categories depending on functionality: 9_1, 9_2, 9_3, 10_0, 10_1 and 11_0. A card only meets a feature level if it is fully compliant to that level, and each level is a strict super-set of those below it. Functionality is minimally emulated to assure no unexpected performance cliffs are encountered. Thus, features like Geometry Shaders are not available for Direct3D 9 level targets.

Runtime Binaries

All runtime binaries provided in the Direct3D 11 tech preview that will be available on Windows 7 and Windows Vista SP1 are installed with the SDK and are labeled as "Beta" components (i.e. D3D11_beta.DLL). All beta-labeled components are time-bombed. To create projects to evaluate these new components, you must link to their equivalent beta-labeled import libraries (i.e. D3D11_beta.lib). If you have a PDC copy of Windows 7, the headers, libs, and pdbs provided in the Windows SDK with the build are appropriate for development using the Direct3D 11 components providing in Windows 7. Please reserve the use of the headers, libs, and pdbs in this SDK to the beta components provided herein.

D3DX11

D3DX11 current only supports texture loading functions for Direct3D 11 resources. In the future, this component will provide many of the technologies available in D3DX10 like a mesh container format as well as the Effects 11 system. An important difference between D3DX11 and D3DX10 is that D3DX11 does not contain shader compilation functionality. Instead this is provided directly through the D3D Compiler component, described below.

HLSL and Direct3D Compiler

The HLSL compiler has several new features for supporting the new technologies available in Direct3D 11. This includes object oriented programming through interfaces and classes, a direct indexing syntax for resource loads, and the 'precise' keyword for ensuring that all operations performed with a specific variable adhere to the strict floating point rules. Almost all new linguistic features have valid functionality on existing shader targets. In addition to supporting all Direct3D 9, Direct3D 10, Direct3D 10.1, and Direct3D 11 shaders the HLSL compiler also supports the special targets needed to write shaders for Direct3D 10 Level 9 targets. The D3D Compiler is now directly accessible outside of D3DX10 and D3DX11 through D3DCompiler.H and D3DCompiler.lib. With these new files, an application is not required to link to D3DX in order to perform runtime compilation, and an application is not required to include the compiler if only D3DX functionality is needed.

D3D11 Reference Rasterizer

The Reference Rasterizer provides a gold-standard rasterization implementation for evaluation of Direct3D 11 features not yet available in hardware. The Reference Rasterizer is also provided as a way to verify a specific hardware implementation's accuracy to the rasterization standard. The reference rasterizer is designed for correctness, not performance. To create a reference device, simply pass the D3D_DRIVER_TYPE_REFERENCE flag at device creation.

D3D11 SDK Layers

Direct3D11 SDK Layers provide a mechanism for tracking the operation of the Direct3D 11 runtime during development. Currently this is used for providing useful debug information, which not only includes errors on improper use but also warnings that recommend best practice use of the runtime and often provides in-depth, useful information for debugging. It is highly recommended that the debug output from D3D11 SDK Layers is turned on at all times during development and an application generates no debug output during execution before it is released or used with PIX for Windows for profiling. Enabling the debug layer is as simple as passing the D3D11_CREATE_DEVICE_DEBUG flag at device creation time. Developers are strongly encouraged to use layers in debug builds. Layers are not recommended for use in profile or release builds.

New Samples Demonstrating D3D11

This release has four new samples that demonstrate D3D11.

The Dynamic Shader Linkage 11 sample demonstrates use of Shader Model 5 shader interfaces and Direct3D 11 support for linking shader interface methods at runtime.
The HDRToneMappingCS11 sample demonstrates how to setup and run the Compute Shader(CS for short later on), which is one of the most exciting new features of Direct3D 11. Although the sample only utilizes the CS to implement HDR tone-mapping, the concept should extend easily to other post-processing algorithms as well as more general calculations.
The MultithreadedRendering11 sample demonstrates how to split rendering among multiple threads, with very low overhead.
The new SubD11 sample is very similar to the SubD10 sample in the DirectX SDK, except that it has been enhanced to take advantage of three new Direct3D 11 pipeline stages: the hull shader, the tessellator, and the domain shader.

Known Issues with the November 2008 SDK

Building Samples Using the Visual Studio 2005 Project Files Results In Harmless Warning

Developers who build the samples may see the following harmless warning:

manifest authoring warning 81010002: Unrecognized Element "requestedPrivileges" in namespace "urn:schemas-microsoft-com:asm.v2".

This is a known issue with the manifest tool (mt.exe) that ships in Visual Studio 2005 SP1. In order to remove this warning, developers should update their versions of mt.exe to the version that ships in the Windows SDK. Developers should update the three instances of mt.exe that ship in Visual Studio 2005 SP1:

VC\bin\
Common7\tools\bin\
SDK\v2.0\bin\
Reflect and DisassembleXXXXX Moved from D3DX10_40.dll to D3DCompiler_40.dll

In the November 2008 DirectX SDK three functions were moved from D3DX10_40.dll to D3DCompiler_40.dll:

D3DX10ReflectShader (renamed D3DReflect)
D3DX10DisassembleShader (renamed D3DDisassemble)
D3DX10DisassembleEffect (renamed D3DDisassemble10Effect)
As part of this change, these three functions are now defined in d3dcompiler.h.

These three new functions use D3D11 interfaces that are fully compatible with D3D10 and D3D10.1 runtimes without taking dependencies that are currently in pre-release state.

Don't Mix Beta DLLs With Their Correspondingly Named Non-Beta DLLs

The Direct3D 11 Technical Preview in the November 2008 DirectX SDK provides a dxgi_beta.dll that is different from the dxgi.dll included in Windows Vista. Developers should not use interfaces from one of these DLLs with the other as it may cause issues that are difficult to track down. The recommendation is that if you are using a beta DLL, don't link to the correspondingly named non-beta DLL.

ID3DXSPMesh Interface Is Deprecated

The ID3DXSPMesh interface is deprecated and will be removed in a future release of the DirectX SDK. Developers should investigate using Direct3D 11 tessellation as an altertnative to the ID3DXSPMesh interface.

D3DXGatherFragments Is Deprecated

The D3DXGatherFragments function is deprecated and will be removed in a future release of the DirectX SDK. Developers should investigate using Direct3D 11 dynamic shaders.

IXACT3Engine::PrepareWave Doesn't Support xWMA

In the March 2008 and later SDKs, the IXACT3Engine::PrepareWave doesn't support xWMA. Titles wishing to use xWMA in XACT can prepare those waves using one of the following methods:

IXACT3WaveBank::Prepare
IXACT3SoundBank::Prepare
IXACT3Engine::PrepareInMemoryWave
IXACT3Engine::PrepareStreamingWave
xWMA Compression Doesn't Support AIFF Sources

In the March 2008 and later SDKs, content creators must use WAV files if they want to use xWMA compression. The AIFF file format can be used for ADPCM and XMA compression.

XAudio2: Queries about Volume, Pitch, Frequency Ratio, and Filter Parameters May Not Return Currently Set Values

In the August 2007 and later SDKs, changing state (such as the volume, pitch, frequency ratio, filter parameters, and others) is deferred. The following methods will all return the most recently set value, even if that value hasn't yet been applied to the sounds.

IXAudio2Voice::GetChannelVolumes
IXAudio2Voice::GetOutputMatrix
IXAudio2Voice::GetVolume
IXAudio2SourceVoice::GetFilterParameters
IXAudio2SourceVoice::GetFrequencyRatio
XACT Fails Silently When Saving to Protected Directories on Windows Vista

On Windows Vista, XACT fails silently when a user tries to save XACT project files to a protected directory such as "Program Files"; to the user, it will look like the save was successful.

XACT Platform-Specific Compression Restrictions

In XACT, users should ensure that compression presets are valid for a given wave on all platforms; if compression fails, the wave reverts to the use of a no compression preset, and, therefore, is uncompressed on all platforms. For Windows exclusive titles, ensure that the Xbox 360 format setting is PCM to avoid this issue. On Xbox 360, ensure that all XMA-compressed waves are 16-bit. On Windows and Xbox 360, ensure that all xWMA-compressed waves use xWMA's supported sampling rates.

Symbols for DirectX

The latest and most complete source for debugging symbols is the Microsoft Symbol Server. We recommend using the symbol server rather than using the included partial symbols package. For instructions about using the Microsoft Symbol Server, see http://www.microsoft.com/whdc/devtools/debugging/debugstart.mspx.

Installation Notes for All Platforms

This SDK installs on Windows XP, Windows Server® 2003, Windows Server 2008, and Windows Vista using Visual Studio .NET 2005 or 2008.
Before installing the current DirectX SDK, remove previous versions of the DirectX SDK.
Some samples require that you install the latest Microsoft Windows SDK (Platform SDK) on your system.
If you are using Visual Studio and run the Platform SDK Integration tool, all custom include and library paths will be erased, including those added by the DirectX SDK. To fix the issue, developers will need to either reinstall the DirectX SDK or manually add the paths to Visual Studio.
If you encounter compilation issues related to the DirectX headers, make sure that the include directories in Visual Studio are set correctly. On the Win32 platform, make sure that there is a reference to the DirectX headers. "$(DXSDK_DIR)include" should appear in the include directory "$(VCInstallDir)Include."
Several virus protection software applications interfere with SDK installation. They may require you to disable virus protection software until SDK installation is completed.
If you encounter the error message "A cabinet file is necessary for installation and cannot be trusted" during installation, your system may be corrupted, or cryptographic services may be disabled. To resolve the problem, try the following:

Enable cryptographic services. On the Start menu, right-click My Computer, and then click Manage. The Computer Management window appears. In the left navigation pane, click Services and Applications. In the right pane, double click Services, and then double-click Cryptographic Services. The Cryptographic Services Properties property sheet appears. On the General tab, ensure that Service Status is Started, and that Startup Type is Automatic.
If you are running Windows on a FAT32 drive, run scandisk.
Try the resolution steps in Detecting digital signing issues in Windows XP.
Try the resolution steps in You cannot install some updates or programs.
Remove temporary files in %temp%. If you are installing end-user runtime, also remove "%windir%\system32\directx\websetup Error."
External firewall programs may indicate that the file InstallDeveloperFiles.exe wants to access the Internet. This is by design, and should be enabled.

[算法] 动态规划：最长公共子串 LCS

北极冰仔 — Tue, 28 Oct 2008 14:43:20 +0000

我的算法学得好差，尤其是动态规划这一块，在这里吃了不少亏。

这次写的跟面试题有关。老早就知道最长公共子串（Longest Common Substring）这个问题，但从没认真搞过，这些天又过着伪充实的繁忙生活，直到今天才终于有点时间和心情（很重要）学习学习了。

原理啥的我还是不讲了，听我讲不如点击上面的链接自行阅读维基。下面我还是贴贴代码吧，写这点东西还是花了点时间的。

For the example strings "ABAB" and "BABA":

	A	B	A	B
	0	0	0	0
B	0	1	0	1
A	1	0	2	0
B	0	2	0	3
A	1	0	3	0

貌似这里应该配个图表

/************************************************************************
The following tricks can be used to reduce the memory usage of an implementation:
1) Keep only the last and current row of the DP table to save memory (O(min(m,n))
instead of O(mn)).
2) Store only non-zero values in the rows. You can do this by using hash tables
instead of arrays. This is useful for large alphabets.
[http://en.wikipedia.org/wiki/Longest_common_substring_problem]
/************************************************************************/

#include
#include
#include
#include
#include

#define GET_MAX(a, b) ((a)> (b) ? (a) : (b))
#define GET_MIN(a, b) ((a) <(b) ? (a) : (b))

#define MAX_LEN 256

#define OUTPUT

/* must free() return value manually */
/* 时间复杂度为O(mn) */

/* 空间复杂度为O(mn) */
char* longest_common_substring(const char* lhs, const char* rhs)
{
size_t llen, rlen, **lens, maxlen = 0, flag = 0;
size_t i, j;
char* buf;

assert(lhs && rhs);

llen = strlen(lhs);
rlen = strlen(rhs);

lens = (size_t**)malloc(llen * sizeof(size_t*));
memset(lens, 0, llen * sizeof(size_t*));
for (i = 0; i )
{
lens[i] = (size_t*)malloc(rlen * sizeof(size_t));
memset(lens[i], 0, rlen * sizeof(size_t));
}

for (i = 0; i )
{
for (j = 0; j )
{
if (lhs[i] == rhs[j])
{
if (0 == i || 0 == j)
lens[i][j] = 1;
else
lens[i][j] = lens[i - 1][j - 1] + 1;
if (lens[i][j]> maxlen)
{
maxlen = lens[i][j];
flag = i;
}
}
#ifdef OUTPUT
printf("%2d", lens[i][j]);
}
printf("\n");
#else
}
#endif
}

for (i = 0; i )
free(lens[i]);
free(lens);

buf = (char*)malloc(maxlen + 1);
memset(buf, 0, maxlen + 1);
strncpy_s(buf, maxlen + 1, lhs + flag - maxlen + 1, maxlen);

return buf;
}

/* 空间复杂度为O(max(m, n))，还没实现O(min(m, n)) */
char* longest_common_substring_2(const char* lhs, const char* rhs)
{
size_t llen, rlen, max, maxlen = 0, flag = 0;
size_t *rows[2], i, j;
char* buf;

assert(lhs && rhs);

llen = strlen(lhs);
rlen = strlen(rhs);
max = GET_MAX(llen, rlen);

for (i = 0; i <2; i++)
{
rows[i] = (size_t*)malloc(max * sizeof(size_t));
memset(rows[i], 0, max * sizeof(size_t));
}

for (i = 0; i )
{
for (j = 0; j )
{
if (lhs[i] == rhs[j])
{
if (0 == i || 0 == j)
rows[1][j] = 1;
else
rows[1][j] = rows[0][j - 1] + 1;
if (rows[1][j]> maxlen)
{
maxlen = rows[1][j];
flag = i;
}
}
#ifdef OUTPUT
printf("%2d", rows[1][j]);
}
printf("\n");
#else
}
#endif
memcpy(rows[0], rows[1], max * sizeof(size_t));
memset(rows[1], 0, max * sizeof(size_t)); /* 少了这行搞死我了 */
}

for (i = 0; i <2; i++)
free(rows[i]);

buf = (char*)malloc(maxlen + 1);
memset(buf, 0, maxlen + 1);
strncpy_s(buf, maxlen + 1, lhs + flag - maxlen + 1, maxlen);

return buf;
}

int main()
{
char lhs[MAX_LEN], rhs[MAX_LEN], *ret;

printf("input string 1: ");
gets_s(lhs, MAX_LEN);
if (!*lhs)
strcpy_s(lhs, MAX_LEN, "AABBCCDD");
printf("input string 2: ");
gets_s(rhs, MAX_LEN);
if (!*rhs)
strcpy_s(rhs, MAX_LEN, "BBCCDDAA");

ret = longest_common_substring(lhs, rhs); /* free() manually */
printf("lcs: %s\n", ret);
free(ret);
ret = longest_common_substring_2(lhs, rhs); /* free() manually */
printf("lcs2: %s\n", ret);
free(ret);

return 0;
}

[C/C++] 为什么把常量写在 == 运算符的左边

北极冰仔 — Wed, 20 Aug 2008 07:04:09 +0000

当然，把常量写在 == 运算符的左或右对运算本身没有任何影响，它们仅仅是两种不同的书写风格。所以我敢保证很多人并不会因为看到某些帖子宣称“应该将常量放在左边”就真的改变自己固有的风格，说到底，习惯而已。

不过，将常量写在运算符左边在某种情况下可能会更容易查错。看下面的例子：

片段一，当且仅当 flag == 5 时执行循环体中的内容：

int flag;
...
while (flag == 5)
{
/* do something */
}

片段二，手快敲掉了一个 =，将会导致死循环，因为 flag = 5 总为真，当代码量很大的时候，要 debug 出这样的错误恐怕不太容易：

int flag;
...
while (flag = 5)
{
/* do something */
}

片段三，常量放在左边，即使侧漏了一个 = 号也很安全，编译器会告诉你这里 Error 了：

int flag;
...
while (5 = flag)
{
/* do something */
}

用一句话总结：良好的书写风格可以让臭虫在编译时而不是运行时现身。

[算法] 回溯法：八皇后问题

北极冰仔 — Sat, 09 Aug 2008 13:07:06 +0000

继续引用维基的图来说明（八皇后问题中的）回溯：

下面还是贴代码，程序会对树进行遍历（共 2057 个节点），从中找出所有可能的解（不同解共 92 个，非唯一解）。

#include

#define N 8

int solution[N], j, k, count, sols;

int place(int row, int col)
{
for (j = 0; j )
{
if (row - j == solution[row] - solution[j] || row + solution[row] == j + solution[j] || solution[j] == solution[row])
return 0;
}
return 1;
}

void backtrack(int row)
{
count++;
if (N == row)
{
sols++;
for (k = 0; k )
printf("%d\t", solution[k]);
printf("\n\n");
}
else
{
int i;
for (i = 0; i )
{
solution[row] = i;
if (place(row, i))
backtrack(row + 1);
}
}
}

void queens()
{
backtrack(0);
}

int main(void)
{
queens();
printf("Total Solutions: %d\n", sols);
return 0;
}

[算法] 分治策略：快速排序

北极冰仔 — Thu, 07 Aug 2008 06:34:52 +0000

先引用维基上的一个图，它很形象地展示了快速排序的整个过程：

快速排序的原理可参考上面的链接或任意一本算法教材，让我来讲也讲不清楚，我也是花好久才彻底看明白（基础太差了，汗），所以就贴贴代码好了，有人会说了，快排的代码网上多得很，还要你来贴干嘛。因为这些代码是我看着《算法基础》这本书上的原理和图自己琢磨出来的（完工后发现跟别人的代码惊人地雷同，汗汗汗），只有递归的终止条件那里参考了一下现成的代码，留下来当作笔记吧。

#include

int pivot(int a[], int left_, int right_)
{
int i, j, p, k, tmp;
k = i = left_;
j = right_ + 1;
p = a[i];
while (1)
{
while (a[++i] <= p && i );
while (a[--j]> p && j>= left_);
if (i )
{
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
else
break;
}
tmp = a[k];
a[k] = a[j];
a[j] = tmp;
return j;
}

void quick_sort(int a[], int left_, int right_)
{
if (left_ )
{
int p = pivot(a, left_, right_);
quick_sort(a, left_, p - 1);
quick_sort(a, p + 1, right_);
}
}

int main(void)
{
int a[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9};
int len = sizeof(a) / sizeof(int);
quick_sort(a, 0, len - 1);
return 0;
}

我的答案：浙大ACM#1350（The Drunk Jailer）

北极冰仔 — Thu, 24 Jul 2008 05:12:05 +0000

题目地址

A certain prison contains a long hall of n cells, each right next to each other. Each cell has a prisoner in it, and each cell is locked.

One night, the jailer gets bored and decides to play a game. For round 1 of the game, he takes a drink of whiskey, and then runs down the hall unlocking each cell. For round 2, he takes a drink of whiskey, and then runs down the hall locking every other cell (cells 2, 4, 6, …). For round 3, he takes a drink of whiskey, and then runs down the hall. He visits every third cell (cells 3, 6, 9, …). If the cell is locked, he unlocks it; if it is unlocked, he locks it. He repeats this for n rounds, takes a final drink, and passes out.

Some number of prisoners, possibly zero, realizes that their cells are unlocked and the jailer is incapacitated. They immediately escape.

Given the number of cells, determine how many prisoners escape jail.

Input

The first line of input contains a single positive integer. This is the number of lines that follow. Each of the following lines contains a single integer between 5 and 100, inclusive, which is the number of cells n.

Output

For each line, you must print out the number of prisoners that escape when the prison has n cells.

Sample Input

2
5
100

Sample Output

2
10

我的代码是用 C 写的，运行耗时 0 秒，占用内存 392K，比高手们多出了 8K。在内存控制方面我始终把握得不好，不过比刚开始玩时写用了 STL 和类的 C++ 好多了。

#include
#include

int main()
{
int c, i, *cases = 0, *esc = 0;
scanf("%d", &c);
if (0 == c)
return -1;
cases = (int*)malloc(c * sizeof(int));
esc = (int*)malloc(c * sizeof(int));
for (i = 0; i )
{
scanf("%d", cases + i);
char* cells = (char*)malloc(*(cases + i) + 1);
int j;
for (j = 0; j <(*(cases + i)); j++)
*(cells + j) = '0';
*(cells + (*(cases + i))) = '\0';
for (j = 0; j <(*(cases + i)); j++)
{
int k;
for (k = 0; k <(*(cases + i)); k++)
{
if ((j * (1 + k) + k)>= *(cases + i))
break;
if ('0' == *(cells + j * (1 + k) + k))
*(cells + j * (1 + k) + k) = '1';
else if ('1' == *(cells + j * (1 + k) + k))
*(cells + j * (1 + k) + k) = '0';
}
}
*(esc + i) = 0;
for (j = 0; j <(*(cases + i)); j++)
{
if ('1' == *(cells + j))
(*(esc + i))++;
}
free(cells);
}
free(cases);
if (esc)
{
for (i = 0; i )
printf("%d\n", *(esc + i));
free(esc);
}
return 0;
}

#更新：感谢 Jiang 的留言，经过改进，程序占用内存减少了 4K，hooray！下面是改进后的代码。（起初我以为不在最后把计算结果一起输出会 WA，事实上每次计算结束就输出也是 AC。再次感谢 Jiang！）

#include
#include

int main()
{
int c, i, j, k, n, *cases = 0, e;
scanf("%d", &c);
if (0 == c)
return -1;
cases = (int*)malloc(c * sizeof(int));
for (i = 0; i )
{
e = 0;
scanf("%d", cases + i);
n = *(cases + i);
char* cells = (char*)malloc(n + 1);
for (j = 0; j )
cells[j] = '0';
cells[n] = '\0';
for (j = 0; j )
for (k = j; k 1)
cells[k]++;
for (j = 0; j )
{
if (1 == cells[j] % 2)
e++;
}
printf("%d\n", e);
free(cells);
}
free(cases);
return 0;
}

Google C++ 编程风格指南（1）：头文件（2）

北极冰仔 — Fri, 11 Jul 2008 15:58:29 +0000

Google C++ 编程风格指南（1）：头文件（2）

-inl.h 文件
函数的参数顺序
头文件名称的顺序

-inl.h 文件

当需要的时候，你应该使用带有 -inl.h 后缀的名字来定义复杂的内联函数。

内联函数的定义需要放在一个头文件里，使得编译器在发生函数调用的地点展开函数定义。尽管如此，实现代码出现在 .cc 文件中更为合适，我们不想让 .h 文件拥有太多的代码，除非那样做可以提高可读性或是性能。

如果一个内联函数的定义很短小，你应该将其放在 .h 文件中。例如，accessors 和 mutators 应该始终放在类定义之内。更加复杂的内联函数也应该放在一个 .h 文件内以方便实现和调用，尽管这样会造成 .h 文件太笨重。解决方法就是将这些代码放入一个单独的 -inl.h 文件内，虽然会导致它与类的定义相分离，但仍然允许实现部分在必要的时候被包含。

-inl.h 文件的另一个用法是定义模板函数，它用来保持你的模板定义容易被读懂。

不要忘记像任何其它头文件那样，给 -inl.h 写一个 #define 宏。

函数的参数顺序

定义一个函数时，参数顺序应该是：先输入、后输出。

C/C++ 函数的参数既可以是输入，也可以是输出，或者二者皆是。输入参数通常是值或 const 引用，输出参数通常是 non-const 指针。当为函数的参数排序时，应把所有只作为输入的参数放在任意输出参数前面。尤其不要把新添加的参数放在函数的最后仅仅因为它们是新添加的；把新添加的输入参数放在输出参数之前。

这不是一条死规矩。那些同时既是输入又是输出的参数（经常是类/结构体）会把水搅浑。所以，遇到这样的函数时，你可以不完全遵守这一条。

头文件名称的顺序

按标准顺序使用头文件会增强代码的可读性，并可避免引入隐式对 C 库、C++ 库或其它库的、你的库的头文件的依赖。

一个工程的所有头文件都应该放入工程源代码目录下，而不要使用 UNIX 目录的快捷方式：.（当前目录）或 ..（上级目录）。例如：google-awesome-project/src/base/logging.h 应该被这样包含：

#include "base/loggin.h"

在一个主要目的是实现或测试 dir2/foo2.h 的 dir/foo.cc 文件中，将头文件按以下顺序包含：

dir2/foo2.h（优先位置）
C 系统文件
C++ 系统文件
其它库的头文件
你的工程的头文件

优先位置会减少隐式依赖。我们希望每个头文件被分别编译，达到这个目的的最简单途径就是保证它们是某个 .cc 文件中包含的第一个 .h 文件。

dir/foo.cc 和 dir2/foo2.h 经常在相同的目录下（例：base/basictypes_unittest.cc 和 base/basictypes.h），但是也可以是不同的目录。

最好在每个片段中按字母顺序包含头文件。

例：google-awesome-project/src/foo/internal/fooserver.cc 中包含的头文件看上去差不多是这个样子：

#include "foo/public/fooserver.h" // 优先位置

#include
#include

#include "base/basictypes.h"
#include "base/commandlineflags.h"
#include "foo/public/bar.h"

别摸我｜catch the digital flow » C/C++

Visual Studio 用 debug 启动调试挂起，提示 Visual Studio Is Busy

Related Posts

float 转换 DWORD 的陷阱

Related Posts

Google 在 Twitter 上的二进制问候是什么

Related Posts

DirectX Software Development Kit (November 2008) 下载

ORIGIN

下载地址（直接用迅雷）

Brief Description

Quick Details

System Requirements

Additional Information

Related Posts

[算法] 动态规划：最长公共子串 LCS

Related Posts

[C/C++] 为什么把常量写在 == 运算符的左边

Related Posts

[算法] 回溯法：八皇后问题

Related Posts

[算法] 分治策略：快速排序

Related Posts

我的答案：浙大ACM#1350（The Drunk Jailer）

Related Posts

Google C++ 编程风格指南（1）：头文件（2）

Google C++ 编程风格指南（1）：头文件（2）

-inl.h 文件

函数的参数顺序

头文件名称的顺序

Related Posts