模板

#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int lowbit(int x)					//make sure the set of the array 
{
	return x&(-x);
}
int sum(int end ,int all[])			//solve sum
{
	int sum=0;
	while(end > 0)
	{
		sum+=all[end];
		end-=lowbit(end);
	}
	return sum;
}
void puls(int set, int num, int all[], int n)			//array number increase or decrease 
{
	while(set <= n)								//网上这里有等于，这个是对的，所以一开始数组需要开大一点
	{
		all[set] += num;
		set += lowbit(set);
	}
}
struct data	
{
	string str;
	int i,j;
};
int main()
{
	int T, count=0;
	scanf("%d",&T);
	while(T--)
	{
		int all[50500];
		int N;
		memset(all, 0, sizeof(all) );
		scanf("%d",&N);
		for(int i=1; i<=N; i++)						
			/*
			因为题目的关系这里从1开始输入数据，以便在计算总和时把漏掉的i加上时不会越界
			*/
		{
			int temp;
			scanf("%d",&temp);
			puls(i ,temp, all, N);
		}
		
		data temp;
		printf("Case %d:
",++count);
		while(cin>>temp.str && temp.str!="End")
		{
			scanf("%d%d",&temp.i,&temp.j);
			if(temp.str =="Query" )
			{
				
				printf("%d
",sum(temp.j,all)-sum(temp.i-1,all) );		
				/*
				i-1 pay attention 
				the problem describe solve j-i ( Query i j ,i和j为正整数,i<=j，表示询问第i到第j个营地的总人数;)
				so all[i] could be ignore !
				*/
			}
			if(temp.str == "Add" )
			{
				puls(temp.i ,temp.j, all, N);
			}
			if(temp.str =="Sub")
				puls(temp.i ,-temp.j, all, N);
		}
		
	}
	return 0;
}
#include <iostream>
#include <stdlib.h>
//use recurrence way to find most biggest total 
using namespace std;
int sum=0;
void print_value(int a[][110],int N)							//printf the number 
{
	for(int row=1; row<=N; row++)
		for(int line=1; line<=row; line++)
			cin>>a[row][line];
}
void search(int a[][110], int i, int j, int N, int all)			//find the most biggest number
{
	all+=a[i][j];
	if(i==N)
	{
		if(sum <all )
			sum =all ;
		return ;
	}
	search(a ,i+1 ,j ,N, all);
	search(a ,i+1 ,j+1 ,N ,all);
}
int main()
{
	int N;
	cin>>N;
	int value[110][110]={0};
	print_value(value,N);
	search(value ,1 ,1 ,N , 0);
	cout<<sum<<endl;
	return 0;
}
#include <iostream>
//#include <algorithm>
#include <stdio.h>
#include <stack>
#include <string.h>
using namespace std;
/*
shadow喜欢听音乐，于是v11自己写了个播放器送给了shadow，这个播放器有一个播放列表，一个“下一首”按钮，一个“上一首”按钮，还有一个播放记录。
一开始播放器会播放播放列表中的第一首歌，当按下“下一首”按钮时，它会播放当前歌曲在播放列表中的下一首歌，若当前歌曲就是播放列表中的最后一首歌时，它仍会播放播放列表中的最后一首歌；当按下“上一首”按钮时，它会清除播放记录中的最后一首歌，并播放清除后播放记录中的最后一首歌，若清除后播放记录为空，则播放播放列表中的第一首歌；当按下播放列表中的某一首歌曲，它会播放该首歌曲。
任何时候，当播放器播放一首歌时，如果该歌曲与播放记录中的最后一首不同或者播放记录为空，便将该歌曲添加到播放记录中成为最后一首。
*/
int main()
{
	
	int T;
	cin>>T;
	while(T--)
	{	stack <int > num;			//变量一定要放在里面，一定要，在计数的时候！！！！！
		int n,m;
		cin>>n>>m;
		char pre[10]="PRE",next[10]="NEXT",play[10]="PLAY";
		char temp[10];
		getchar();
		for(int i=1;i<=m;i++)
		{
			gets(temp);
			char *p=temp;
			if(strstr(p,"PLAY")!=NULL)
			{
				int a=atoi( (p+5) );
				cout<<a<<endl;
				if( num.size()==0||a!=num.top()  )
				num.push(a);
			}
			if(strcmp(temp,pre)==0 )
			{
				if(num.empty() ==0)
				num.pop();
				if(num.empty() )
				{/*num.push(1);*/cout<<'1'<<endl;}
				else
				{cout<<num.top()<<endl;}
			}
			if(strcmp(temp,next)==0 )
			{
				if(num.empty() )
				{cout<<'2'<<endl;num.push(2);}
				else if(num.top()==n)
				{
					cout<<n<<endl;
					//num.push(n);
				}
				else
				{
					cout<<(num.top()+1)<<endl;
					num.push(num.top()+1);
				}
			}
			
		}
	}
	return 0;
}
#include <stdio.h>
#include <iostream>
#include <stack>
#include <string>
#include <string.h>
using namespace std;
int main()
{
	int n;
	//string in,out;
	char in[1000],out[1000];
	while(cin>>n>>in>>out)
	{
		//stack<char> s;
		char s[1000];
		memset(s,'',sizeof(s) );
		int mark[20];
		int i=0,j=0;
		int count=0;
		while(i<n)
		{
			//if(s.empty() )
			if(strlen(s)==0)
			{
				//s.push(in[i]);
				s[count++]=in[i];
				mark[i+j]=0;
				i++;
			}
			//if(!s.empty() && s.top()!=out[j] )
			if(strlen(s)!=0 && s[strlen(s)]!=out[j] )
			{
				//s.push(in[i]);
				s[count++]=in[i];
				mark[i+j]=0;
				i++;
			}
			//while(!s.empty() &&s.top() ==out[j] )
			while(strlen(s)!=0 && s[strlen(s)-1]==out[j] )
			{
				//s.pop();
				s[strlen(s)-1]='';
				mark[i+j]=1;
				j++;
			}
		}
		//if( s.empty() )
		if(strlen(s)==0 )
		{
			cout<<"Yes."<<endl;
			for(int i=0;i<2*n;i++)
			{
				if(mark[i]==0)
					cout<<"in"<<endl;
				else
					cout<<"out"<<endl;
			}
			cout<<"FINISH"<<endl;
		}
		else
			cout<<"No."<<endl<<"FINISH"<<endl;
	}
	return 0;
}
/*
Problem Description
看病要排队这个是地球人都知道的常识。
不过经过细心的0068的观察，他发现了医院里排队还是有讲究的。0068所去的医院有三个医生（汗，这么少）同时看病。而看病的人病情有轻重，所以不能根据简单的先来先服务的原则。所以医院对每种病情规定了10种不同的优先级。级别为10的优先权最高，级别为1的优先权最低。医生在看病时，则会在他的队伍里面选择一个优先权最高的人进行诊治。如果遇到两个优先权一样的病人的话，则选择最早来排队的病人。
现在就请你帮助医院模拟这个看病过程。
 
Input
输入数据包含多组测试，请处理到文件结束。
每组数据第一行有一个正整数N(0<N<2000)表示发生事件的数目。
接下来有N行分别表示发生的事件。
一共有两种事件：
1:"IN A B",表示有一个拥有优先级B的病人要求医生A诊治。(0<A<=3,0<B<=10)
2:"OUT A",表示医生A进行了一次诊治，诊治完毕后，病人出院。(0<A<=3)
 
Output
对于每个"OUT A"事件，请在一行里面输出被诊治人的编号ID。如果该事件时无病人需要诊治，则输出"EMPTY"。
诊治人的编号ID的定义为：在一组测试中，"IN A B"事件发生第K次时，进来的病人ID即为K。从1开始编号。
*/
#include <queue>
#include <iostream>
#include <string>
using namespace std;
struct node
{
	string in;
	int A,B;
	int count;
};
struct cmp
{
	bool operator() (const node &a, const node &b)
	{
		if (a.B > b.B)
             return false;
		else if(a.B ==b.B)
			return (a.count > b.count);
		else
		return true;
	}
};
int main()
{
	int n;
	while(cin>>n)
	{
		node temp;
		priority_queue <node, vector<node>, cmp> que1;
		priority_queue <node, vector<node>, cmp> que2;
		priority_queue <node, vector<node>, cmp> que3;
		int a=0;
		while(n--)
		{	
			cin>>temp.in;
			if(temp.in=="IN")
				cin>>temp.A>>temp.B;
			if(temp.in=="OUT")
				cin>>temp.A;
			if(temp.in=="IN")
			{
			switch (temp.A)
				{
				case 1:{temp.count=++a;que1.push(temp);break;}
				case 2:{temp.count=++a;que2.push(temp);break;}
				case 3:	{temp.count=++a;que3.push(temp);break;}
				}
			}
			if(temp.in=="OUT")
			{
				switch (temp.A)
				{
					case 1:{if(que1.empty() )	{cout<<"EMPTY"<<endl;break;}	else {cout<<que1.top().count<<endl;que1.pop();break;}	}
					case 2:{if(que2.empty() )	{cout<<"EMPTY"<<endl;break;}	else {cout<<que2.top().count<<endl;que2.pop();break;}	}
					case 3:{if(que3.empty() )	{cout<<"EMPTY"<<endl;break;}	else {cout<<que3.top().count<<endl;que3.pop();break;}	}
				}
			}
		}
	}
		return 0;
}
/*
Problem Description
看病要排队这个是地球人都知道的常识。
不过经过细心的0068的观察，他发现了医院里排队还是有讲究的。0068所去的医院有三个医生（汗，这么少）同时看病。而看病的人病情有轻重，所以不能根据简单的先来先服务的原则。所以医院对每种病情规定了10种不同的优先级。级别为10的优先权最高，级别为1的优先权最低。医生在看病时，则会在他的队伍里面选择一个优先权最高的人进行诊治。如果遇到两个优先权一样的病人的话，则选择最早来排队的病人。
现在就请你帮助医院模拟这个看病过程。
 
Input
输入数据包含多组测试，请处理到文件结束。
每组数据第一行有一个正整数N(0<N<2000)表示发生事件的数目。
接下来有N行分别表示发生的事件。
一共有两种事件：
1:"IN A B",表示有一个拥有优先级B的病人要求医生A诊治。(0<A<=3,0<B<=10)
2:"OUT A",表示医生A进行了一次诊治，诊治完毕后，病人出院。(0<A<=3)
 
Output
对于每个"OUT A"事件，请在一行里面输出被诊治人的编号ID。如果该事件时无病人需要诊治，则输出"EMPTY"。
诊治人的编号ID的定义为：在一组测试中，"IN A B"事件发生第K次时，进来的病人ID即为K。从1开始编号。
*/
#include <queue>
#include <iostream>
#include <string>
using namespace std;
struct node
{
	string in;
	int A,B;
	int count;
};
struct cmp
{
	bool operator() (const node &a, const node &b)
	{
		if (a.B > b.B)
             return false;
		else if(a.B ==b.B)
			return (a.count > b.count);
		else
		return true;
	}
};
int main()
{
	int n;
	while(cin>>n)
	{
		node temp;
		priority_queue <node, vector<node>, cmp> que1;
		priority_queue <node, vector<node>, cmp> que2;
		priority_queue <node, vector<node>, cmp> que3;
		int a=0;
		while(n--)
		{	
			cin>>temp.in;
			if(temp.in=="IN")
				cin>>temp.A>>temp.B;
			if(temp.in=="OUT")
				cin>>temp.A;
			if(temp.in=="IN")
			{
			switch (temp.A)
				{
				case 1:{temp.count=++a;que1.push(temp);break;}
				case 2:{temp.count=++a;que2.push(temp);break;}
				case 3:	{temp.count=++a;que3.push(temp);break;}
				}
			}
			if(temp.in=="OUT")
			{
				switch (temp.A)
				{
					case 1:{if(que1.empty() )	{cout<<"EMPTY"<<endl;break;}	else {cout<<que1.top().count<<endl;que1.pop();break;}	}
					case 2:{if(que2.empty() )	{cout<<"EMPTY"<<endl;break;}	else {cout<<que2.top().count<<endl;que2.pop();break;}	}
					case 3:{if(que3.empty() )	{cout<<"EMPTY"<<endl;break;}	else {cout<<que3.top().count<<endl;que3.pop();break;}	}
				}
			}
		}
	}
		return 0;
}
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#define max_one 100
#define max_two 50
#define max_three 50
using namespace std;
struct node												//structure must sign first 
{
	string str;
	int size;
	
};
									//return the most minimum string
									//pay attention :
struct cmp							//must complete size first then complete string 
{
	bool operator() (const node &a, const node &b)
	{
		if(a.size >b.size)
		return true;
		else if(a.size ==b.size)
			return a.str>b.str;
		else return false;
	}
};
priority_queue <node, vector<node>, cmp> que;
void score_string(char *p, char *q, int two, int three)				//score string into queue 
{
	string temp="";
	if(p>q)
	{
		int length=three > p-q+two ? three : p-q+two;
		for(int i=0; i<length ;i++)
			temp+=*(q+i);
		node a;
		a.str=temp;
		a.size=length;
		que.push(a);
	}
	else if(p<q)
	{
		int length=two > q-p+three ? two : q-p+three;
		for(int i=0; i<length ;i++)
			temp+=*(p+i);
		node a;
		a.str=temp;
		a.size=length;
		que.push(a);
	}
	else if(p=q)											//pay attention : p=q such as this string
															//one :asdfgh	two :asdfgh  three:a;
	{
		int length=two >three ? two :three;
		for(int i=0; i<length ;i++)
			temp+=*(p+i);
		node a;
		a.str=temp;
		a.size=length;
		que.push(a);
	}
}
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		while(!que.empty() )									//each text must clean the queue 
		{
			que.pop();
		}
		char one[max_one],two[max_two],three[max_three];
		cin>>one>>two>>three;
		int two_length=strlen(two);							//score size of two three string 
		int three_length=strlen(three);
		char *p=strstr(one,two);
		char *q=strstr(one,three);
		if(p==NULL ||q==NULL)
		cout<<"No"<<endl;
		else
		{
			char *two_point[max_two];						//set pointer array score the possible way of string 
			char *three_point[max_three];
			two_point[0]=p;three_point[0]=q;
			int size_two=1;
			char *temp_two=p,*temp_three=q;
			while( (temp_two=strstr(temp_two+1,two))!=NULL)					//get different substring way
				two_point[size_two++]=temp_two;
			int size_three=1;
			while( (temp_three=strstr(temp_three+1,three))!=NULL)
				three_point[size_three++]=temp_three;
			for(int i=0; i<size_two; i++)					//score 
			{
				for(int j=0; j<size_three; j++)
					score_string(two_point[i], three_point[j], two_length, three_length);
			}
			cout<<que.top().str<<endl;
		}
		//cout<<que.top().str<<endl;
		
	}
	return 0;
}
/*Description
Businesses like to have memorable telephone numbers. One way to make a telephone number memorable is to have it spell a memorable word or phrase. For example, you can call the University of Waterloo by dialing the memorable TUT-GLOP. Sometimes only part of the number is used to spell a word. When you get back to your hotel tonight you can order a pizza from Gino's by dialing 310-GINO. Another way to make a telephone number memorable is to group the digits in a memorable way. You could order your pizza from Pizza Hut by calling their ``three tens'' number 3-10-10-10. 
The standard form of a telephone number is seven decimal digits with a hyphen between the third and fourth digits (e.g. 888-1200). The keypad of a phone supplies the mapping of letters to numbers, as follows: 
A, B, and C map to 2 
D, E, and F map to 3 
G, H, and I map to 4 
J, K, and L map to 5 
M, N, and O map to 6 
P, R, and S map to 7 
T, U, and V map to 8 
W, X, and Y map to 9 
There is no mapping for Q or Z. Hyphens are not dialed, and can be added and removed as necessary. The standard form of TUT-GLOP is 888-4567, the standard form of 310-GINO is 310-4466, and the standard form of 3-10-10-10 is 310-1010. 
Two telephone numbers are equivalent if they have the same standard form. (They dial the same number.) 
Your company is compiling a directory of telephone numbers from local businesses. As part of the quality control process you want to check that no two (or more) businesses in the directory have the same telephone number. 
Input
The input will consist of one case. The first line of the input specifies the number of telephone numbers in the directory (up to 100,000) as a positive integer alone on the line. The remaining lines list the telephone numbers in the directory, with each number alone on a line. Each telephone number consists of a string composed of decimal digits, uppercase letters (excluding Q and Z) and hyphens. Exactly seven of the characters in the string will be digits or letters. 
Output
Generate a line of output for each telephone number that appears more than once in any form. The line should give the telephone number in standard form, followed by a space, followed by the number of times the telephone number appears in the directory. Arrange the output lines by telephone number in ascending lexicographical order. If there are no duplicates in the input print the line: 
No duplicates. 
*/
#include <iostream>
#include <math.h>
#include <string>
#include <map>
using namespace std;
#include <fstream>
//ifstream fin("C:\Users\yw\Desktop\E\E.2.dat");
//ofstream fout("result1.txt");
//#define cout fout
//#define cin fin
int main()
{
	int n;
	cin>>n;
	//getchar();
	map<string,int>result;							//存结果对应的map的
	 map< string,int>::iterator iter;				//建立反向迭代器
	map<char,int>num;
	// char num[91];
	num['A' ]=num['B']=num['C']='2';				//字母对应的数字
	num['D' ]=num['E']=num['F']='3';
	num['G' ]=num['H']=num['I']='4'; 
	num['J' ]=num['K']=num['L']='5';
	num['M' ]=num['N']=num['O']='6';
	num['P' ]=num['R']=num['S']='7';
	num['T' ]=num['U']=num['V']='8';
	num['W' ]=num['X']=num['Y']='9';
	
	while(n--)
	{
		char word[100];							//注意字符可能很多
		cin>>word;
		char *p=word;
		string temp="";
		int count=0;
		while(	(*p)!='')						//转换数字
		{
			if(	(*p>='A'&&*p<'Q')||(*p>'Q'&&*p<'Z')	)
			{
				temp+=num[*p];
				count++;	p++;
				if(count==3)
				temp+='-';
			}
			else if( *p>='0'&&*p<='9' )
			{
				temp+=(*p);
				count++;	p++;
				if(count==3)
					temp+='-';
			}
			else p++;
		}
		iter=result.find(temp);							//查找时候在map里面有
		if(iter==result.end() )
			result[temp]=1;
		else 
			result[temp]=iter->second+1;				//有就数字加一
	}
	int ok=1;
	for(iter = result.begin(); iter != result.end(); iter++)			//利用方向迭代器输出数据
	{
		if(iter->second>1)
		{cout<<iter->first<<' '<<iter->second<<endl;	ok=0;}
	}
	if(ok)	cout<<"No duplicates."<<endl;
	return 0;
}
最小生成树
Prim算法：
#define SIZE	1100
#define INF		0x7fffffff
int map[1100][1100], weight[1100], pre[1100], length, point;		
bool sign[1100];
map	存路径，值为权值；		weight保存个点到源起点的权值；		pre保存结点的前驱，即与源起点有路的下一个点
length	生成的最短距离		point 图上共有多少点				sign该点是否已经找过
算法prim
从一个结点的子图开始构造生成树：选择连接当前子图和子图外结点的最小权边，将相应结点和边加入子图，直至将所有结点加入子图
void prim(int weight[],int map[][SIZE], int pre[], bool sign[], int &length, int point_num, int source)
{														//source源起点，一定要是路径中有的
	for(int i=1; i<=point_num; i++)						//这里的路径的标号都 > 1，记录所以点到源起点的权值，前驱，将该点置为已经查找
	{
		weight[i] = map[source][i];
		pre[i] = source;		sign[i] = true;
	}
	sign[source] = false;  length = 0;
	
	for(int i=1; i<point_num; i++)					//枚举n-1个点，即n-1个通路
	{
		int min = INF, sign_node = i;				//sign_node	记录找到的最小的下一个点
		for(int j=1; j<=point_num; j++)				//查找最小权值的路径
		{
			if(sign[j] && weight[j] < min)
			{min = weight[j]; sign_node = j;}
		}
		{sign[sign_node] = false;	length += min;	}	//找到点置为已找到，长度相加,
														//可以在这里添加一个标记，使他值等于min，如果最后值等于最大值，则不能生成最小生成树
			
		for(int j=1; j<=point_num; j++)									//重新设定源起点，将剩下的未找的点加入
		{
			if(weight[j] > map[sign_node][j] &&	sign[j] )
			{weight[j] = map[sign_node][j];		pre[j] = sign_node;}
		}}}
并查集
算法：
初始化
把每个点所在集合初始化为其自身。
通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O(N)。
查找：	查找元素所在的集合，即根节点。
合并：	将两个元素所在的集合合并为一个集合。
通常来说，合并之前，应先判断两个元素是否属于同一集合，这可用上面的“查找”操作实现。
int father[1100], total（初始化为端点数减一）;
void join(int a, int b)				//将a,b最后统一
{
	int find(int );
	int fa = find(a), fb = find(b);
	if(fa != fb)
	{father[fa] = fb;	total--;}	//因为是读入两个有关联的路径，所以添加路径数减一
}
int find(int x)
{
	int temp = father[x];
	while( temp != father[temp])
		temp = father[temp];
	
	return temp;
}

来自为知笔记(Wiz)