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;
}

#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转换为二进制的字符串，再把该字符串转换为整数。

#include<cstdio>
const int MAX = 10000;
const int INF = 1000000;
int d[MAX];
int c[MAX][MAX];
bool flag[MAX];
//int path[MAX];
int Dijkstra(int beg, int n)
{
	int i, j, u, tmp;
	for(i = 1; i <= n; i++)
	{
		d[i] = c[beg][i];
		flag[i] = false;
		/*if(d[i] == INF)
			path[i] = 0;
		else
			path[i] = beg;*/
	}
	d[beg] = 0; flag[beg] = true;
	for(i = 1; i <= n; i++)
	{
		tmp = INF; u = beg;
		for(j = 1; j <=n; j++)
		{
			if(!flag[j] && d[j] < tmp)
			{
				u = j; 
				tmp = d[j];
			}
		}
		flag[u] = true;
		for(j  = 1; j <= n; j++)
		{
			if(!flag[j] && c[u][j] < INF)
			{
				if(d[u] + c[u][j] < d[j])
					d[j] = d[u] + c[u][j];
				//path[j] = u;
			}
		}
	}
	return 0;
}
int main()
{	
	return 0;
}

#include<cstdio>
const int MAX=10000;
const int INF=1000000;
int d[MAX][MAX];
int floyd (int n)
{

	for(int k =1 ; k <= n; k++)
	{
		for(int i = 1; i <= n; i++)
		{
			for(int j = 1; j <= n; j++)
			{
				if(d[i][k] + d[k][j] < d[i][j])
					d[i][j] = d[i][k] + d[k][j];
			}
		}
	}
        return 0;
}
int main()
{
	return 0;
}
floyd后，如果d[i][j]>=INF，则点i到点j没有路。
else点i到点j的最短路径长度为d[i][j]。

bool prime(int a)
{
	for(int i=2;i<=sqrt(a);i++)
	{
		if(a%i==0)
			return false;
	}
	return true;
}

#ifndef UFSET_H
#define UFSET_H
class UFset
{
	public:
		UFset(int);
		void Union(int ,int);
		int Find(int);
		int & operator [] (int i){return parent[i];}
		int size(){return length;}
	private:
		int length;//集合的个数
		int * parent;
};
UFset::UFset(int len)
{
	length = len;
	parent = new int [length + 1];
	for(int k = 1; k <= length; k++)
		parent[k] = -1;
}
int UFset::Find(int x)
{
	 int i;
	 for(i = x; parent[i] >= 0; i = parent[i]);//搜索根节点
	 while(i!=x)//路径压缩
	 {
		  int tmp = parent[x];
		  parent[x] = i;
		  x = tmp;
	 }
	 return i;
}
void UFset::Union(int x,int y)//合并
{
	int pX = Find(x);
	int pY = Find(y);
	if(pX != pY)
	{
		int tmp = parent[pX] + parent[pY];
		if(parent[pX] > parent[pY])
		{
			parent[pX] = pY;
			parent[pY] = tmp;
		}
		else 
		{
			parent[pY] = pX;
			parent[pX] = tmp;
		}
		length--;
	}
}
#endif

The Triangle
Time Limit:1000MS  Memory Limit:10000K
Total Submit:3415 Accepted:1988

Description

7

3   8

8   1   0

2   7   4   4

4   5   2   6   5


(Figure 1)

Input
Your program is to read from standard input. The first line contains one integer N: the number of rows in the triangle. The following N lines describe the data of the triangle. The number of rows in the triangle is > 1 but <= 100. The numbers in the triangle, all integers, are between 0 and 99.

Output
Your program is to write to standard output. The highest sum is written as an integer.

Sample Input

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

Sample Output
30


分析：
题意简化为：
从第一行开始走到最后一行，每步可以向下走或右下走。
所求即为从第一行走到最后一行经过的数总和的最大值。
令p[][]存储input。
5
7
3 8
8 1 0
2 7 4 4
|     \ |  \
4 5 2 6 5

如上图，令i为行，j为列,
d[i][j]为从第一行走到第i行第j列的最大值。
对于(i,j)这个点，它可以从不同方向走来，如图' | '代表从上方走来，' \ '代表从左上方走来。

则动态规则方程为：
                  {     d[i-1][1]+p[i][1]   (j=1)
d[i][j]=Max{     Max( d[i-1][j-1] , d[i-1][j] ) + p[i][j]   (1<j<i)
                  {     d[i-1][i-1]+p[i][i]   (j=i)

结果为Max(d[n][j]) , (1<=j<=n)

代码如下：

#include<cstdio>
int p[100][100];
int d[100][100];
int Max(int a,int b)
{return a>b?a:b;}
int main()
{
	int i,n;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		int j;
		for(j=1;j<=i;j++)
			scanf("%d",p[i]+j);
	}
	d[1][1]=p[1][1];
	for(i=2;i<=n;i++)
	{
		int j;
		d[i][1]=d[i-1][1]+p[i][1];
		for(j=2;j<=i;j++)
			d[i][j]=Max(d[i-1][j-1],d[i-1][j])+p[i][j];
		d[i][i]=d[i-1][i-1]+p[i][i];
	}
	int max=0;
	for(i=1;i<=n;i++)
	{
		if(d[n][i]>max)
			max=d[n][i];
	}
	printf("%d\n",max);
	return 0;
}

Gopher and hawks
Time Limit:1000MS  Memory Limit:65536K
Total Submit:900 Accepted:328

Description
A gopher sits in a hole located at (xs, ys) and wants to get to a hole located at (xt, yt). The gopher can run at a constant speed of v m/sec. However, if the gopher is outside of a hole for more than a m minutes he will become a supper to hawks flying over the holes. Can the gopher make it?

Input
The first line of input contains two positive integer numbers: v -- gopher's speed in meters per second and m -- the time after which the gopher becomes prey to hawks if he stays outside a hole. The second line of input contains two floating point numbers: the (xs,ys) coordinates of the gopher starting hole. The third line contains the (xt, yt) coordinates of the target hole. Each Subsequent line of input contains two floating point numbers: the (x,y) coordinates of a gopher hole. All distances are in metres, to the nearest mm.

Output
If the gopher can make it to the target hole, the output line should read "Yes, visiting n other holes.", where n is the minimal number of intermediate holes the gopher has to visit. If the gopher cannot make it the output line should read "No." There are not more than 1000 gopher holes and all coordinates are between -10000 and +10000.

Sample Input

3 1
0.000 0.000
500.000 0.000
179.000 0.000
358.000 0.000

Sample Output

Yes, visiting 2 other holes.

Hint
Sample input 2
5 1
0.000 0.000
0.000 550.000
179.000 0.000
0.000 301.000

Output for sample input 2
No.

我的程序：
#include<cstdio>
#include<cmath>
#include<queue>
using namespace std;
struct node
{
	int point;
	int step;
};
double x[1100],y[1100];
bool flag[1100]={false};
int main()
{
	int i,v,t;
	scanf("%d%d",&v,&t);
	t*=60;
	double beginX,beginY,endX,endY;
	scanf("%lf%lf%lf%lf",&beginX,&beginY,&endX,&endY);
	int n=1;
	while(scanf("%lf%lf",x+n,y+n)!=EOF)
		n++;
	x[0]=beginX;
	y[0]=beginY;
	x[n]=endX;
	y[n]=endY;

	node n1;//队列初始化
	n1.point=0;
	n1.step=0;
	queue<node> que;
	que.push(n1);

	int steps=0;
	while(true)
	{
		if(que.empty())
			break;
		node tmp=que.front();
		que.pop();//出队列
		for(i=1;i<=n;i++)
		{
			if(!flag[i])//标志是否进过队列
			{				
				double time=sqrt(pow(x[i]-x[tmp.point],2.0)+pow(y[i]-y[tmp.point],2.0))/v;
				if(time<t)
				{
					if(i==n)
					{
						steps=tmp.step;
						goto next;
					}
					else
					{
						node in;
						in.point=i;
						in.step=tmp.step+1;
						que.push(in);//进队列
						flag[i]=true;
					}
				}
			}
		}
	}
	next:
	if(steps!=0)
		printf("Yes, visiting %d other holes.\n",steps);
	else
		printf("No.\n");
	return 0;
}

My Status

Solved 4    Time 460

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

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

结果当然就是错了。

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

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

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

记住了！！

从此不能犯同样错误！