const int VMAX = 1010;
typedef struct Graph
{
    int vex;
    Graph* next;
}Graph;
Graph ArcGraph[VMAX];
void insert(int u, int v)
{
    Graph* t = new Graph;
    Graph* p = ArcGraph[u].next;
    t->vex = v;
    t->next = p;
    ArcGraph[u].next = t;
}

完成完整的程序提交上去，得到结果
Memory:25796K  Time:375MS
Language:C++  Result:Accepted

再对比别人的程序
Memory:296K Time:109MS

无论是时间还是空间都相差很大。
于是就考虑怎么优化自己的程序。
第一个问题：规模只有1000，为什么会用那么多内存呢？
仔细一想数据是多case的，每次插入新节点时都要动态创建一个节点。
一来动态创建耗时间，二来每个case结束的邻接表中的节点没有释放，故耗费大量内存。
然后就想到了下面的算法，首先初始化一块内存Graph use[100*VMAX];这样每次需要新节点时，
就从use中获取。如果use使用完毕就再动态创建。

依此算法优化后，得到的结果比较满意
Memory:1000K  Time:218MS
Language:C++  Result:Accepted

const int VMAX = 1010;
typedef struct Graph
{
    int vex;
    Graph* next;
}Graph;
Graph ArcGraph[VMAX];
Graph use[100*VMAX];
int size = 0;
void insert(int u, int v)
{
    Graph* t;
    if(size < 100*VMAX)
    {
        t = &use[size];
        size++;
    }
    else t = new Graph;
    Graph* p = ArcGraph[u].next;
    t->vex = v;
    t->next = p;
    ArcGraph[u].next = t;
}

priority_queue<int> qi;

通过<操作符可知在整数中元素大的优先级高。
故示例1中输出结果为：9 6 5 3 2

第二种方法：
在示例1中，如果我们要把元素从小到大输出怎么办呢？
这时我们可以传入一个比较函数，使用functional.h函数对象作为比较函数。

priority_queue<int, vector<int>, greater<int> >qi2;

其中
第二个参数为容器类型。
第二个参数为比较函数。
故示例2中输出结果为：2 3 5 6 9

第三种方法：
自定义优先级。

struct node
{
    friend bool operator< (node n1, node n2)
    {
        return n1.priority < n2.priority;
    }
    int priority;
    int value;
};

在该结构中，value为值，priority为优先级。
通过自定义operator<操作符来比较元素中的优先级。
在示例3中输出结果为：
优先级  值
9          5
8          2
6          1
2          3
1          4
但如果结构定义如下：

struct node
{
    friend bool operator> (node n1, node n2)
    {
        return n1.priority > n2.priority;
    }
    int priority;
    int value;
};

则会编译不过（G++编译器）
因为标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。
而且自定义类型的<操作符与>操作符并无直接联系，故会编译不过。

//代码清单

#include<iostream>
#include<functional>
#include<queue>
using Namespace stdnamespace std;
struct node
{
    friend bool operator< (node n1, node n2)
    {
        return n1.priority < n2.priority;
    }
    int priority;
    int value;
};
int main()
{
    const int len = 5;
    int i;
    int a[len] = {3,5,9,6,2};
    //示例1
    priority_queue<int> qi;
    for(i = 0; i < len; i++)
        qi.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi.top()<<" ";
        qi.pop();
    }
    cout<<endl;
    //示例2
    priority_queue<int, vector<int>, greater<int> >qi2;
    for(i = 0; i < len; i++)
        qi2.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi2.top()<<" ";
        qi2.pop();
    }
    cout<<endl;
    //示例3
    priority_queue<node> qn;
    node b[len];
    b[0].priority = 6; b[0].value = 1; 
    b[1].priority = 9; b[1].value = 5; 
    b[2].priority = 2; b[2].value = 3; 
    b[3].priority = 8; b[3].value = 2; 
    b[4].priority = 1; b[4].value = 4; 

    for(i = 0; i < len; i++)
        qn.push(b[i]);
    cout<<"优先级"<<'\t'<<"值"<<endl;
    for(i = 0; i < len; i++)
    {
        cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;
        qn.pop();
    }
    return 0;
}

scanf()函数是通用终端格式化输入函数，它从标准输入设备(键盘) 读取输入的信息。可以读入任何固有类型的数据并自动把数值变换成适当的机内格式。

其调用格式为:      scanf("<格式化字符串>"，<地址表>);

scanf()函数返回成功赋值的数据项数，出错时则返回EOF。

其控制串由三类字符构成：

1。格式化说明符；
2。空白符；
3。非空白符；

（A）                格式化说明符

格式字符           说明

%a                 读入一个浮点值(仅C99有效)
%A                 同上
%c                 读入一个字符
%d                 读入十进制整数
%i                 读入十进制，八进制，十六进制整数
%o                 读入八进制整数
%x                 读入十六进制整数
%X                 同上
%c                 读入一个字符
%s                 读入一个字符串
%f                 读入一个浮点数
%F                 同上
%e                 同上
%E                 同上
%g                 同上
%G                 同上
%p                 读入一个指针
%u                 读入一个无符号十进制整数
%n                 至此已读入值的等价字符数
%[]                扫描字符集合
%%                 读%符号

#include<iostream>
#include<sstream>
using namespace std;
int main()
{
	string str, line;
	while(getline(cin, line))
	{
		istringstream stream(line);
		while(stream>>str)
			cout<<str.c_str()<<endl;
	}	
	return 0;
}

#include<cstdlib>
#include<cstdio>
int main()
{
	int num = 10;
	char str[100];
	int n = atoi(itoa(num, str, 2));
	printf("%d\n",n);
	return 0;
}
先把num转换为二进制的字符串，再把该字符串转换为整数。

[Andrew Koeing & Barbara MOO] Accelerated C++
Accelerated c++, Andrew Koeing & Barbara MOO, Addison Wesley, 2000

[Eckel2000] Thinking in C++
Thinking in C++ 2/e Bruce Eckel 2000 1470 pages Prentice Hall
C++ 编程思想，刘宗田等 译，420页

[Lippman98] C++Primer
C++ Primer,3rd Editoin,by Stanley Lippman and Josee Lajoie
Addison Wesley Longman,1998 1237 pages
C++ Primer 中文版，侯俊杰 译，1999，1237页

[Struostrup2000] The C++ Programming Language
The C++ Programming Language,Special Editoin,by Bjarne Stroustrup
Addison Wesley Longman,2000,1017 pages

[ANSI C++] C++规格书 1998.9.1 PDF格式
ANSI C++ 1996 Draft

层级二：专家经验(C++/OOP)
[Meyers96] More Effective C++
More Effective C++, by Scott Meyers,Addison Wesley,1996,318pages
More Effective C++中文版，侯俊杰，培生 2000. 318页

[Meyers98] Effective C++
Effective C++, Second Edition,by Scott Meyers,Addison Wesley Longman,1998.256pages
Effective C++ 2/e 中文版,侯俊杰,培生 2000.256页
Effective C++, Third Edition, by Scott Meyers, Addison Wesley Longman.

[Sutter99] Exceptional C++
Exceptional C++，by Herb Sutter,Addison Wesley Longman,2000.208pages
Exceptional C++中文版，侯俊杰,培生 2000.248页

[Sutter2001]More Exceptional C++
More Exceptional C++ by Herb Sutter, Addison Wesley Longman, 2001.

[Sutter2004]Exception C++ Style
Exception C++ Style by Herb Sutter, Addison Wesley Longman, 2004.

层级三：底层机制(C++ Object Model)
[Ellis90] The Annotated C++ Reference Manual
The Annotated C++ Reference Manual,by Margaret A.Ellis and Bjarne Stroustrup
Addison Wesley Longman,1990,447 pages.

[Lippman96] Inside the C++ Object Model
Inside the C++ Object Model,by Stanley Lippman,Addison Wesley Longman,1996,280pages
深度探索C++物件模型，侯俊杰 译

层级四：设计观念的复用(C++/Patterns)
[Gamma95] Design Patterns：Elements of Reusable Object Oriented Software,
by Erich Gamma,Richard Helm,Ralph Johnson,and John Vlissides,Addison Wesley,1995.395pages
设计模式,李英军等译,机械工业出版社,2000.254页

[Alex2001]Modern C++ Design: Generic Programming and Design Patterns Applied
by Andrei Alexandrescu,Addison-Wesley,2001,352Paper

Genericity/STL系列(与层级二同步）:
第一个境界是使用STL:
[Josuttis99]:The C++ Standard Library －A Tutorial and Reference,by Nicolai M.Josuttis,
Addison Wesley 1999.799pages

第二个境界是了解泛型技术的内涵与STL的学理:
[Austern98]:Generic Programming and the STL -Using and Extending the C++ Standard
Template library,by Matthew H.Austern,Addison Wesley 1998.548page

第三个境界是扩充STL:
[Stepanov2001]:C++ Standard Template Library by P.J.Plauger,Alexander A.Stepanov,
Meng Lee,David R.Musser,Prentice Hall 2001

其他书目：
1. Large-scale C++ software Design, John Lako, Addison Wesley, 1996
2. Effective STL, Scott Meyers, Addison Wesley, 1995
3. C++ FAQs, 2nd, Marshall Cline, Greg Lomow, Mike Girou, Addison Wesley, 1998
4. C++ Gotchas, Stephen Dewhurst, Addison Wesley, 2002
5. C++ templates, the complete Guide, Daveed Vandevoorde & Nicolar M.Josuttis, Addison Wesley, 2002
6. Standard C++ iostreams and Locals, Angelika Langer & Klaus Kreft, Addison Wesley, 2000
7. Design & Evolution of C++, BS, Addison Wesley, 1994
8. Modern C++ Design, Andrie Alexandrescu, Addison Wesley, 2001
9. Generative Programming, Krzysztof Czarnecki & Ulrich Eisencecker, Addison Wesley, 2000
10.Pattern-oriented software architecture, Vol1:A system of patterns, Frank Buschmann, 1996
11. STL 源码剖析，侯杰
12. C++ Coding Standards 101 Rules Guidelines, Andrie Alexandrescu & Herb Sutter, Addison Wesley, 2005

find.h
#ifndef FIND_H
#define FIND_H
template <typename ITER , typename T>
ITER find(ITER begin, ITER end, T value)
{
	ITER it;
	for(it = begin; it != end; ++it)
		if(*it == value)
			break;
	return it;
}
#endif

count.h
#ifndef COUNT_H
#define COUNT_H
template <typename ITER , typename T>
int count(ITER begin, ITER end, T value)
{
	int sum = 0;
	for(ITER it = begin; it != end; ++it)
	{
		if(*it == value)
			++sum;
	}
	return sum;
}
#endif

以后接着写。

这里以string类为例：

1、string str1 = "";
2、string str2 = string();
3、string str3;

第一种方式：调用string类接受字符串形参的构造函数，创建一个临时对象。
然后调用复制构造函数用该对象初始化str1。

第二种方式：调用string类的默认构造函数，创建一个临时对象。
然后调用复制构造函数用该对象初始化str2。

第三种方式：直接调用string类的默认构造函数初始化str3。

创建临时对象的代价是高的。

因此创建对象应尽量不要使用会创建临时对象的初始化方式。

在使用类时也尽量不要创建临时对象。

它能自动识别各种关键字，系统函数，成员变量，

自动给出输入提示，自动更正大小写错误，

自动标示错误，等等等等。

用了它，你写代码的速度一定大大提高。

看到一段代码：

char *p1,*p2;
//something
if(p1!=0)strcpy(p2,p1);

奇怪，指针怎么能够和0相比呢？

N days later...

一个有效的指针有三种状态：

一、保存一个特定对象的地址。

二、指向某个对象后面的另一对象。

三、值为0，表明它不指向任何对象。

if(p1!=0)strcpy(p2,p1);
<=>
if(p1!=NULL)strcpy(p2,p1);// 这种形式更易理解。

NULL 是在 cstdlib 头文件中定义的变量，值为0.

操作不存在的元素，如:

#include<iostream>
#include<string>
using namespace std;
int main()
{
       string str;
       cin>>str[0];
       cout<<str[0];
       return 0;
}

这样得到输出的结果是不确定的。

因为在这里创建的是一个空 string 类，

长度为0，值为""(空)。

因此不存在str[0]。

在函数内定义了一个一百万的数组。

编译、连接没问题，但执行时就会提示堆栈溢出。

但定义全局变量却没有问题。

谁能给我解释一下为什么？

对于下面一段程序：

#include<iostream>
using namespace std;
int main()
{
     for(int i=0;i<10;i++)
     {/*content*/}
  
     for(int i=0;i<10;i++)
     {/*content*/}   

      return 0;
}

在VC 6.0编译器中是“i” redefinition。

而在Dev-C++编译器中是完全正确的。

我也一直搞不清楚i的作用域是什么。

直到看过Primer后才知道有一种作用域叫做“语句作用域”。

就是说就上述问题的i只能在for语句中使用。

这就是说这是VC 6.0的一个Bug,真是这样吗？

题目说明要输入的字符串长度最多为8。

因此我就只申请了8个字符。

结果当然就是错了。

其实字符数组需要一个存储单元来保存结束符“\0”，

用来说明一个字符串结束了。

因此要申请比字符串多一个存储单元的长度。

记住了！！

从此不能犯同样错误！