diff --git a/1005.cpp b/1005.cpp
new file mode 100644
index 0000000..89c512f
--- /dev/null
+++ b/1005.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+
+#include <cstdlib>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	string s;
+	cin >> s;
+	int num = 0;
+	for(int i = 0; i < s.size(); ++i) {
+		num += s[i] - '0';
+	}	
+	const char *numbers[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
+
+	stringstream ss;
+	ss << num;
+	ss >> s;
+	for(int i = 0; i < s.size()-1; ++i) {
+		cout << numbers[s[i] - '0'] << " ";
+	}
+	cout << numbers[s[s.size()-1] - '0'] << endl;
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1006.cpp b/1006.cpp
new file mode 100644
index 0000000..1926cdb
--- /dev/null
+++ b/1006.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+using namespace std;
+
+class checkRecord
+{
+public:
+	string id;
+	string checkIn;
+	string checkOut;
+	/* data */
+};
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	cin >> n;
+	vector<checkRecord> v;
+	for(int i = 0; i < n; ++i) {
+		checkRecord tmp;
+		cin >> tmp.id >> tmp.checkIn >> tmp.checkOut;
+		v.push_back(tmp);
+	}
+	string earlyId, lateId;
+	string earlyTime = "99:99:99", lateTime = "00:00:00";
+	for(int i = 0; i < v.size(); ++i) {
+		if(v[i].checkIn <= earlyTime) {
+			earlyId = v[i].id;
+			earlyTime = v[i].checkIn;
+		}
+	}
+	for(int i = 0; i < v.size(); ++i) {
+		if(v[i].checkOut >= lateTime) {
+			lateId = v[i].id;
+			lateTime = v[i].checkOut;
+		}
+	}
+	cout << earlyId << " " << lateId << endl;
+	return 0;
+}
\ No newline at end of file
diff --git a/1007.cpp b/1007.cpp
new file mode 100644
index 0000000..320219a
--- /dev/null
+++ b/1007.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <vector>
+
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+struct record
+{
+	int sum;
+	int startIndex;
+	int endIndex;
+	/* data */
+};
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	scanf("%d", &n);
+	vector<int> v(n, 0);
+	for(int i = 0; i < n; ++i) {
+		scanf("%d", &v[i]);
+	}
+	record maxSum;
+	maxSum.sum = -1;
+	record tmp;
+	tmp.sum = -1;
+	tmp.startIndex = 0;
+	for(int i = 0; i < n; ++i) {
+		if(-1 == tmp.sum && v[i] < 0) {
+			tmp.startIndex = i + 1;
+			continue;
+		}
+		else if(-1 == tmp.sum && v[i] >= 0) {
+			tmp.sum = 0;
+			tmp.startIndex = i;
+		}
+		tmp.endIndex = i;
+		tmp.sum += v[i];
+		if(tmp.sum > maxSum.sum) {
+			maxSum.sum = tmp.sum;
+			maxSum.startIndex = tmp.startIndex;
+			maxSum.endIndex = tmp.endIndex;
+		}
+		else if(tmp.sum < 0) {
+			tmp.sum = -1;
+			tmp.startIndex = i+1;
+		}
+	}
+	if(maxSum.sum < 0)
+		printf("0 %d %d\n", v[0], v[n-1]);
+	else
+		printf("%d %d %d\n", maxSum.sum, v[maxSum.startIndex], v[maxSum.endIndex]);
+	return 0;
+}
\ No newline at end of file
diff --git a/1008.cpp b/1008.cpp
new file mode 100644
index 0000000..a920eab
--- /dev/null
+++ b/1008.cpp
@@ -0,0 +1,27 @@
+#include <iostream>
+#include <algorithm>
+
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	scanf("%d", &n);
+	int now = 0, result = 0, next;
+	for(int i = 0; i < n; ++i) {
+		scanf("%d", &next);
+		if(now >= next) {
+			result += (now - next) * 4 + 5;
+		}
+		else {
+			result += (next - now) * 6 + 5;
+		}
+		now = next;
+	}
+	printf("%d\n", result);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1009.cpp b/1009.cpp
new file mode 100644
index 0000000..2629aa1
--- /dev/null
+++ b/1009.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <vector>
+
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+const int MAXNUM = 1001;
+const int MAXPLUS = 2001;
+
+int main(int argc, char const *argv[])
+{
+	vector<double> v1(MAXNUM, 0);
+	vector<double> v2(MAXNUM, 0);
+	vector<double> result(MAXPLUS, 0);
+	int n, nk;
+	double ak;
+	scanf("%d", &n);
+	for(int i = 0; i < n; ++i) {
+		scanf("%d%lf", &nk, &ak);
+		v1[nk] = ak;
+	}
+	scanf("%d", &n);
+	for(int i = 0; i < n; ++i) {
+		scanf("%d%lf", &nk, &ak);
+		v2[nk] = ak;
+	}
+
+	for(int i = 0; i < MAXNUM; ++i) {
+		for(int j = 0; j < MAXNUM; ++j) {
+			if(0 == v1[i] || 0 == v2[j])
+				continue;
+			result[i+j] += v1[i] * v2[j]; 
+		}
+	}
+	int total = 0;
+	for(int i = 0; i < MAXPLUS; ++i) {
+		if(0 != result[i]) {
+			++total;
+		}
+	}
+	printf("%d", total);
+	for(int i = MAXPLUS-1; i >= 0; --i) {
+		if(0 != result[i]) {
+			printf(" %d %.1f", i, result[i]);
+		}
+	}
+	printf("\n");
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1010.cpp b/1010.cpp
new file mode 100644
index 0000000..f957523
--- /dev/null
+++ b/1010.cpp
@@ -0,0 +1,69 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+
+using namespace std;
+
+typedef long long lint;
+
+int trans(char c) {
+	if(c >= '0' && c <= '9')
+		return c - '0';
+	else if(c >= 'a' && c <= 'z')
+		return c - 'a' + 10; 
+	return 0;
+}
+
+lint s2int(string s, int radix) {
+	lint result = 0;
+	for(int i = 0; i < s.size(); ++i) {
+		result = result * radix + trans(s[i]);
+		if(result < 0) {
+			return -1;
+		}
+	}
+	return result;
+}
+
+int main(int argc, char const *argv[])
+{
+	string s1;
+	string s2;
+	int tag, radix;
+	cin >> s1 >> s2 >> tag >> radix;
+	if(2 == tag)
+		swap(s1, s2);
+	lint a = 0;
+	for(int i = 0; i < s1.size(); ++i) {
+		a = a * radix + trans(s1[i]);
+	}
+	int minRadix = -1;
+	for(int i = 0; i < s2.size(); ++i) {
+		minRadix = max( minRadix, trans(s2[i]) );
+	}
+	++minRadix;
+	lint cur = 0, pre = -1;
+	
+	lint low = max(minRadix, 2), high = a + 1, mid;
+
+	lint result = -1;
+	while(low <= high) {	
+		mid = (low + high) / 2;
+		cur = s2int(s2, mid);
+		if( cur >= a || -1 == cur ){
+			if( cur == a && (mid < result || -1 == result) )
+				result = mid;
+			high = mid - 1;
+		}
+		else {
+			low = mid + 1;
+		}
+	}
+	if(result != -1){
+		cout << result << endl;
+	}
+	else
+		cout << "Impossible" << endl;
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1011.cpp b/1011.cpp
new file mode 100644
index 0000000..32d045e
--- /dev/null
+++ b/1011.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	double bet[3][3];
+	const char out[3] = {'W', 'T', 'L'};
+	for(int i = 0; i < 3; ++i)
+		scanf("%lf%lf%lf", &bet[i][0], &bet[i][1], &bet[i][2]);
+	double a[3];
+	double result = 1.0;
+	for(int i = 0; i < 3; ++i) {
+		a[i] = max( bet[i][0], max(bet[i][1], bet[i][2]) );
+		result *= a[i];
+		for(int j = 0; j < 3; ++j) {
+			if(a[i] == bet[i][j]) {
+				printf("%c ", out[j]);
+				break;
+			}
+		}
+	}
+	result = (a[0] * a[1] * a[2] * 0.65 - 1.0) * 2.0 ;
+	printf("%.2f\n", result);
+
+	return 0;
+}
diff --git a/1012.cpp b/1012.cpp
new file mode 100644
index 0000000..4f04b82
--- /dev/null
+++ b/1012.cpp
@@ -0,0 +1,115 @@
+#include <iostream>
+#include <vector>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+class Student{
+public:
+	string id;
+	int A;
+	int C;
+	int M;
+	int E;
+	bool operator < (const Student & rhs) const {
+		return id < rhs.id;
+	}
+	bool operator == (const Student & rhs) const {
+		return id == rhs.id;
+	}
+};
+
+bool cmpID(const Student &lhs, const Student &rhs)  {
+	return lhs.id < rhs.id;
+}
+
+bool cmp(int a, int b){
+	return a > b;
+}
+
+vector<Student> vs;
+vector<string> vid;
+map<string, vector<int> > m;
+int main(int argc, char const *argv[])
+{
+	int N, M;
+	scanf("%d%d", &N, &M);
+	
+	Student tmpStudent;
+	for(int i = 0; i < N; ++i) {
+		cin >> tmpStudent.id >> tmpStudent.C >> tmpStudent.M
+			>> tmpStudent.E;
+		tmpStudent.A = tmpStudent.C + tmpStudent.M + tmpStudent.E;
+		vs.push_back(tmpStudent);
+		m[tmpStudent.id] = vector<int>(4, -1);
+	}	
+	
+	string tmpStr;
+	for(int i = 0; i < M; ++i) {
+		cin >> tmpStr;
+		vid.push_back(tmpStr);
+		m[tmpStr] = vector<int>(4, -1);
+		// m.insert(pair<string, vector<int> >(tmpStr, vector<int>(4, -1)) );
+	}
+
+	sort(vs.begin(), vs.end(), cmpID);
+	vector<Student>::iterator it = unique(vs.begin(), vs.end());
+	vs.erase(it, vs.end());
+
+	vector<int> fun;
+	
+	for(int i = 0; i < vs.size(); ++i)
+		fun.push_back(vs[i].A);
+	sort(fun.begin(), fun.end());
+	
+	for(int i = 0; i < vs.size(); ++i){
+		m[vs[i].id][0] = fun.end() - upper_bound(fun.begin(), fun.end(), vs[i].A) + 1;
+		// cout << vs[i].id << " " << vs[i].A << " " << m[vs[i].id][0] << endl;
+	}
+	fun.clear();
+
+	for(int i = 0; i < vs.size(); ++i)
+		fun.push_back(vs[i].C);
+	sort(fun.begin(), fun.end());
+	for(int i = 0; i < vs.size(); ++i){
+		m[vs[i].id][1] = fun.end() - upper_bound(fun.begin(), fun.end(), vs[i].C) + 1;
+	}
+	fun.clear();
+
+	for(int i = 0; i < vs.size(); ++i)
+		fun.push_back(vs[i].M);
+	sort(fun.begin(), fun.end());
+	for(int i = 0; i < vs.size(); ++i){
+		m[vs[i].id][2] = fun.end() - upper_bound(fun.begin(), fun.end(), vs[i].M) + 1;
+	}
+	fun.clear();
+
+	for(int i = 0; i < vs.size(); ++i)
+		fun.push_back(vs[i].E);
+	sort(fun.begin(), fun.end());
+	for(int i = 0; i < vs.size(); ++i){
+		m[vs[i].id][3] = fun.end() - upper_bound(fun.begin(), fun.end(), vs[i].E) + 1;
+	}
+
+	const char printTable[4] = {'A', 'C', 'M', 'E'};
+	for(int i = 0; i < vid.size(); ++i) {
+		if( m[vid[i]][0] == -1)
+			cout << "N/A" << endl;
+		else {
+			int result = *(min_element(m[vid[i]].begin(), m[vid[i]].end()));
+			for(int j = 0; j < 4; ++j) {
+				if(result == m[vid[i]][j]) {
+					cout << result << " " << printTable[j] << endl;
+					break;
+				}
+			}
+		}
+	}
+
+	return 0;
+}
diff --git a/1013.cpp b/1013.cpp
new file mode 100644
index 0000000..d0003c3
--- /dev/null
+++ b/1013.cpp
@@ -0,0 +1,79 @@
+#include <iostream>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+typedef unsigned int uint;
+
+int findCha(int i, const vector<int> &v) {
+	if(i == v[i])
+		return i;
+	else
+		return findCha(v[i], v);
+}
+
+void makeCha(vector<int> &v, vector<int> &rank) {
+	for(uint i = 0; i < v.size(); ++i)
+		v[i] = i;
+	for(uint i = 0; i < rank.size(); ++i) 
+		rank[i] = 0;
+}
+
+void unionCha(int i, int j, vector<int> &v, vector<int> &rank) {
+	i = findCha(i, v);
+	j = findCha(j, v);
+	if(i == j)
+		return;
+	if(rank[i] > rank[j]) {
+		v[j] = i;
+	}
+	else {
+		v[i] = j;
+		if(rank[i] == rank[j]) {
+			++rank[j];
+		}
+	}
+}
+
+int main(int argc, char *argv[]) {
+	int N, M, K;
+	scanf("%d%d%d", &N, &M, &K);
+	vector< pair<int, int> > path(M, pair<int, int>(0, 0));
+	for(uint i = 0; i < path.size(); ++i) {
+		scanf("%d%d", &(path[i].first), &(path[i].second));
+	}
+	vector<int> check(K, 0);
+	for(uint i = 0; i < check.size(); ++i) {
+		scanf("%d", &check[i]);
+	}
+
+	vector<int> rank(N+1, 0);
+	vector<int> pre(N+1, 0);
+	int target;
+	for(uint i = 0; i < check.size(); ++i) {
+		target = check[i];
+		makeCha(pre, rank);
+		for(uint j = 0; j < path.size(); ++j) {
+			if(target == path[j].first || target == path[j].second)
+				continue;
+			unionCha(path[j].first, path[j].second, pre, rank);
+		
+		}
+		vector<int> tmp(N+1, 0);
+		for(uint j = 1; j <= N; ++j) {
+			++tmp[findCha(j, pre)];
+		}
+		
+		int count = 0;
+		for(uint j = 1; j <= N; ++j) {
+			if(0 != tmp[j])
+				++count;
+		}
+		printf("%d\n", count-2);
+		
+	}
+	
+	return 0;
+}
diff --git a/1014.cpp b/1014.cpp
new file mode 100644
index 0000000..e1405d5
--- /dev/null
+++ b/1014.cpp
@@ -0,0 +1,66 @@
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <queue>
+#include <vector>
+#include <climits>
+
+using namespace std;
+
+const int closeTime = (17- 8) * 60;
+
+struct Customer
+{
+	int processTime;
+	int leaveTime;
+};
+
+int main(int argc, char *argv[]) {
+	int N, M, K, Q;
+	scanf("%d%d%d%d", &N, &M, &K, &Q);
+	vector<Customer> customers(K);
+	for(int i = 0; i < K; ++i){
+		scanf("%d", &customers[i].processTime);
+		customers[i].leaveTime = INT_MAX;
+	}
+	int p = 0, id;
+	vector<int> now(N, 0);
+	vector< queue<int> > mQueue(N);
+	for(; p < K && p < N*M; ++p) {
+		id = p % N;
+		customers[p].leaveTime = now[id] + customers[p].processTime;
+		now[id] = customers[p].leaveTime;
+		mQueue[id].push(p);
+	}
+	for(; p < K; ++p) {
+		int minTime = INT_MAX;
+		int index = 0;
+		for(int i = 0; i < N; ++i) {
+			int topId = mQueue[i].front();
+			if(minTime > customers[topId].leaveTime) {
+				minTime = customers[topId].leaveTime;
+				index = i;
+			}
+		}
+		customers[p].leaveTime = now[index] + customers[p].processTime;
+		now[index] = customers[p].leaveTime;
+		mQueue[index].pop();
+		mQueue[index].push(p);
+	}
+
+	int query;
+	for(int i = 0; i < Q; ++i) {
+		scanf("%d", &query);
+		--query;
+		if(customers[query].leaveTime - customers[query].processTime >= closeTime) {
+			printf("Sorry\n");
+		}
+		else {
+			printf("%02d:%02d\n", 8 + customers[query].leaveTime / 60, customers[query].leaveTime % 60);
+		}
+	}
+
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1015.cpp b/1015.cpp
new file mode 100644
index 0000000..5987312
--- /dev/null
+++ b/1015.cpp
@@ -0,0 +1,87 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+
+using namespace std;
+const int MAXNUM = 100010;
+int f[MAXNUM];
+
+int translateTo10(int number, int radix) {
+	if(10 == radix)
+		return number;
+	int result = 0;
+	int base = 1;
+	while(0 != number) {
+		result += number % 10 * base;
+		base *= radix;
+		number /= 10;
+	}
+	return result;
+}
+
+int translateToRadix(int number, int radix) {
+	if(10 == radix)
+		return number;
+	int result = 0;
+	int base = 1;
+	while(0 != number) {
+		result += number % radix * base;
+		base *= 10;
+		number /= radix;
+	}
+	return result;
+
+}
+
+int reserveInt(int number) {
+	int result = 0;
+	while(0 != number) {
+		result = result * 10 + number % 10;
+		number /= 10;
+	}
+	return result;
+}
+
+int reserveNum(int number, int radix) {
+	int result = 0;
+	while(0 != number) {
+		result = result * radix + number % radix;
+		number /= radix;
+	}
+	return result;
+}
+
+int main(int argc, char *argv[]) {
+	memset( f, 0, sizeof(f) );
+	f[0] = 1;
+	f[1] = 1;
+	for(int i = 2; i < int( pow(1.0*MAXNUM, 0.5) ) + 1; ++i) {
+		if(1 == f[i])
+			continue;
+		for(int j = i + i; j < MAXNUM - 1; j += i) {
+			f[j] = 1;
+		}
+	}
+
+	int number, radix;
+	while(true) {
+		scanf("%d", &number);
+		if(number < 0)
+			break;
+		scanf("%d", &radix);
+		if( 0 == f[ number ] && 
+		//	0 == f[translateTo10( reserveInt( translateToRadix(number, radix) ), radix) ]) {
+			0 == f[ reserveNum(number, radix) ] ){
+			printf("Yes\n");
+		}
+		else {
+			printf("No\n");
+		}
+
+	//	printf("%d\n", reserveInt( translateToRadix(number, radix) ));
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1016.cpp b/1016.cpp
new file mode 100644
index 0000000..dc8498a
--- /dev/null
+++ b/1016.cpp
@@ -0,0 +1,146 @@
+#include <map>
+#include <vector>
+#include <stack>
+#include <string>
+#include <algorithm>
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+struct Record {
+	int mo;
+	int dd;
+	int hh;
+	int mm;
+	bool online;
+	void printRecord() {
+		printf("%02d:%02d:%02d ", dd, hh, mm);		
+	}
+};
+
+struct Call {
+	Record in;
+	Record out;
+	double cost;
+	int len;
+};
+
+bool cmp(const Record &lhs, const Record &rhs) {
+	if(lhs.mo == rhs.mo) {
+		if(lhs.dd == rhs.dd) {
+			if(lhs.hh == rhs.hh) {
+				return lhs.mm < rhs.mm;
+			}
+			else {
+				return lhs.hh < rhs.hh;
+			}
+		}
+		else {
+			return lhs.dd < rhs.dd;
+		}
+	}
+	else {
+		return lhs.mo < rhs.mo;
+	}
+}
+
+Call getCost(const Record &callIn, const Record &callout, int *price) {
+	Call call;
+	Record in = callIn, out = callout;
+	call.in = in;
+	call.out = out;
+	int cost = 0;
+	int len = 0;
+	while( !(in.dd == out.dd && in.hh == out.hh && in.mm == out.mm) ) {
+		cost += price[in.hh];
+		in.mm++;
+		len++;
+		if(60 == in.mm) {
+			in.mm = 0;
+			in.hh++;
+		}
+		if(24 == in.hh) {
+			in.hh = 0;
+			in.dd++;
+		}
+	}
+	call.cost = double(cost)/100.0;
+	call.len = len;
+	return call;
+}
+
+
+const string onLineType = "on-line";
+
+int main(int argc, char *argv[]) {
+	// get input
+
+	int price[24];
+	for(int i = 0; i < 24; ++i)
+		scanf("%d", &price[i]);
+	
+	int n;
+	scanf("%d", &n);
+	string tmpName;
+	string tmpType;
+	map<string, vector<Record> > records;
+	for(int i = 0; i < n; ++i) {
+		cin >> tmpName;
+		Record record;
+		scanf("%d:%d:%d:%d", &record.mo, &record.dd, &record.hh, &record.mm);
+		cin >> tmpType;
+		record.online = tmpType == onLineType;
+		records[tmpName].push_back(record);
+	}
+
+	vector<string> names;
+	for(map<string, vector<Record> >::iterator it = records.begin(); it != records.end(); ++it) {
+		names.push_back(it->first);
+	}
+	sort(names.begin(), names.end());
+	for(int i = 0; i < names.size(); ++i) {
+		vector<Record> &v = records[ names[i] ];
+		sort(v.begin(), v.end(), cmp);
+
+		// stack<int> s;
+		vector<Call> calls;
+		for(int ii = 0; ii < v.size() - 1; ++ii) {
+
+			if(v[ii].online == true && v[ii+1].online == false)
+				calls.push_back( getCost(v[ii], v[ii+1], price) );
+			// if(s.empty()) {
+			// 	if(false == v[ii].online)
+			// 		continue;
+			// 	else 
+			// 		s.push(ii);
+			// }
+			// else {
+			// 	if(true == v[ii].online) {
+			// 		s.push(ii);
+			// 	}
+			// 	else {
+			// 		calls.push_back( getCost(v[s.top()], v[ii], price) );
+			// 		s.pop();
+			// 	} 
+			// }
+		}
+
+		if(0 == calls.size()) 
+			continue;
+
+		cout << names[i];
+		printf(" %02d\n", calls[0].in.mo);
+		double totalCost = 0;
+		for(int ii = 0; ii < calls.size(); ++ii) {
+			calls[ii].in.printRecord();
+			calls[ii].out.printRecord();
+			printf("%d $%.2f\n", calls[ii].len, calls[ii].cost);
+			totalCost += calls[ii].cost;
+		}
+		printf("Total amount: $%.2f\n", totalCost);
+	}
+
+
+}
\ No newline at end of file
diff --git a/1017.cpp b/1017.cpp
new file mode 100644
index 0000000..c2fbd2e
--- /dev/null
+++ b/1017.cpp
@@ -0,0 +1,79 @@
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+struct Customer {
+	int arriveTime;
+	int processTime;
+};
+
+const int beginTime = 8 * 3600;
+const int endTime = 17 * 3600 + 1;
+
+bool cmp(const Customer &lhs, const Customer &rhs) {
+	return lhs.arriveTime < rhs.arriveTime;
+}
+
+int main(int argc, char *argv[]) {
+	int N, K;
+	scanf("%d%d", &N, &K);
+	int hh, mm, ss, process, tmpTime;
+	Customer customer;
+	vector<Customer> serve;
+	for(int i = 0; i < N; ++i) {
+		scanf("%d:%d:%d %d", &hh, &mm, &ss, &process);
+		tmpTime = ss + mm * 60 + hh * 3600;
+		if(tmpTime < endTime) {
+			customer.arriveTime = tmpTime;
+			if(process > 60)
+				process = 60;
+			customer.processTime = process * 60;
+			serve.push_back(customer);
+		}
+	}
+	vector<int> nowTime(K, beginTime);
+	sort(serve.begin(), serve.end(), cmp);
+	int p = 0;
+	int waitTime = 0;
+	for(; p < K && p < serve.size(); ++p) {
+		if(serve[p].arriveTime < beginTime) {		
+			waitTime += beginTime - serve[p].arriveTime;
+			nowTime[p] += serve[p].processTime;
+		}
+		else
+			nowTime[p] = serve[p].arriveTime + serve[p].processTime;
+	}
+	
+	for(; p < serve.size(); ++p) {
+		int windowId = 0, minTime = nowTime[0];
+		for(int i = 1; i < K; ++i) {
+			if(nowTime[i] < minTime) {
+				minTime = nowTime[i];
+				windowId = i;
+			}
+		}
+		// if(minTime >= endTime)
+		// 	break;
+		if(serve[p].arriveTime < nowTime[windowId]) {
+			waitTime += nowTime[windowId] - serve[p].arriveTime;
+			nowTime[windowId] += serve[p].processTime; 
+		}
+		else
+			nowTime[windowId] = serve[p].arriveTime + serve[p].processTime; 
+	}
+
+	// for(; p < serve.size(); ++p) {
+	// 	waitTime += endTime - serve[p].arriveTime - 1;
+	// }
+
+	if(0 == p)
+		printf("0.0\n");
+	else
+		printf("%.1f", double(waitTime) / (p * 60) );
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1019.cpp b/1019.cpp
new file mode 100644
index 0000000..48f4ca4
--- /dev/null
+++ b/1019.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <vector>
+
+#include <cstdlib>
+#include <cstdio>
+
+using namespace std;
+
+typedef long long lint;
+
+void printV(const vector<int> & v) {	
+	for(int i = v.size()-1; i > 0; --i){
+		cout << v[i] << " ";
+	}
+	cout << v[0] << endl;
+}
+
+int main(int argc, char const *argv[])
+{
+	lint a, radix;
+	cin >> a >> radix;
+	vector<int> v;
+	
+	do{
+		v.push_back(a % radix);
+		a /= radix;
+	}while(0 != a);
+
+	for(int i = 0, j = v.size()-1; i < j; ++i, --j){
+		if(v[i] != v[j]) {
+			cout << "No" << endl;
+			printV(v);
+			return 0;
+		}
+	}
+	cout << "Yes" << endl;
+	printV(v);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1020.cpp b/1020.cpp
new file mode 100644
index 0000000..a412fa2
--- /dev/null
+++ b/1020.cpp
@@ -0,0 +1,82 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+struct node{
+	int val;
+	node *left;
+	node *right;
+};
+
+node* returnRoot(const vector<int> &poOrd, const vector<int> &inOrd, int poLeft, int poRight, int inLeft, int inRight) {
+	// cout << poLeft << " " << poRight << " " << inLeft << " " << inRight << endl;
+	if(poRight < poLeft || inRight < inLeft || poRight - poLeft != inRight - inLeft) {
+		return NULL;
+	}
+	node *root = new node;
+	root->val = poOrd[ poRight ];
+	int rootPos = 0, i = inLeft;
+	for(; i <= inRight; ++i) {
+		if(inOrd[i] == root->val)
+			break;
+	}
+	if(i > inRight) {
+		delete root;
+		return NULL;
+	}
+	rootPos = i;
+	int rightNum = inRight - rootPos, leftNum = rootPos - inLeft;
+	root->left = returnRoot(poOrd, inOrd, poLeft, poLeft + leftNum - 1, inLeft, inLeft + leftNum - 1);
+	root->right = returnRoot(poOrd, inOrd, poLeft + leftNum, poRight - 1, inLeft + leftNum + 1, inRight);
+	return root;
+
+}
+
+void levelOrder(node *root) {
+	if(NULL == root)
+		return;
+	vector<int> v;
+	queue<node*> q;
+	q.push(root);
+	while(q.size() != 0) {
+		if(q.front()->left != NULL)
+			q.push(q.front()->left);
+		if(q.front()->right != NULL)
+			q.push(q.front()->right);
+		v.push_back(q.front()->val);
+		q.pop();
+	}
+	printf("%d", v[0]);
+	for(int i = 1; i < v.size(); ++i) {
+		printf(" %d", v[i]);
+	}
+	printf("\n");
+}
+
+int main(int argc, char *argv[]) {
+	int n;
+	scanf("%d", &n);
+	if(n <= 0) {
+		return 0;
+	}
+	vector<int> poOrd(n, 0);
+	vector<int> inOrd(n, 0);
+	for(int i = 0; i < n; ++i) {
+		scanf("%d", &poOrd[i]);
+	}
+	for(int i = 0; i < n; ++i)
+		scanf("%d", &inOrd[i]);
+
+	int poRight = poOrd.size(), inRight = inOrd.size();
+
+	node *root = returnRoot(poOrd, inOrd, 0, poRight-1, 0, inRight-1);
+	// printf("%d\n", root->val);
+	levelOrder(root);
+
+	return 0;
+}
diff --git a/1021.cpp b/1021.cpp
new file mode 100644
index 0000000..619287d
--- /dev/null
+++ b/1021.cpp
@@ -0,0 +1,111 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+
+using namespace std;
+
+// bingcha
+vector<int> pre;
+vector<int> num;
+vector< vector<int> > link;
+queue<int> q;
+
+int find(int a) {
+	while(pre[a] != a) 
+		a = pre[a];
+	return a;
+}
+
+void join(int a, int b) {
+	a = find(a);
+	b = find(b);
+	if(a == b)
+		return;
+	if(num[a] > num[b]) {
+		pre[b] = a;
+	}
+	else {
+		pre[a] = pre[b];
+		num[b]++;
+	}
+}
+
+int main(int argc, char *agrv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+
+	int N;
+	cin >> N;
+	for(int i = 0; i < N; ++i) {
+		pre.push_back(i);
+		num.push_back(1);
+		link.push_back(vector<int>());
+	}
+	
+	for(int i = 0; i < N - 1; ++i) {
+		int a, b;
+		cin >> a >> b;
+		--a;
+		--b;
+		link[a].push_back(b);
+		link[b].push_back(a);
+		join(a, b);
+	}
+
+	// "Error: K components"
+	set<int> s;
+	for(int i = 0; i < N; ++i) {
+		s.insert(pre[i]);
+	}
+	if(1 != s.size()) {
+		printf("Error: %d components\n", s.size());
+		return 0;
+	}
+
+	// find the deepest root
+	vector<int> deep(N, 0);
+	for(int i = 0; i < N; ++i) {
+		vector<bool> visited(N, false);
+		q.push(i);
+		q.push(-1);
+		int curDeep = 0;
+		while(!q.empty()) {
+			int curNode = q.front();
+			if(-1 != curNode)
+				visited[curNode] = true;
+			q.pop();
+			if(-1 == curNode) {
+				if(!q.empty()) {
+					q.push(-1);
+					++curDeep;
+				}
+			}
+			else {
+				for(int j = 0; j < link[curNode].size(); ++j) {
+					if( !visited[ link[curNode][j] ] ) {
+						q.push( link[curNode][j] );
+						visited[ link[curNode][j] ] = true;
+					}
+				}
+			}
+		}
+		deep[i] = curDeep;
+	}
+
+	int maxDeep = -1;
+	for(int i = 0; i < deep.size(); ++i) {
+		maxDeep = max(maxDeep, deep[i]);
+	}
+	for(int i = 0; i < deep.size(); ++i) {
+		if(maxDeep == deep[i])
+			printf("%d\n", i + 1);
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1022.cpp b/1022.cpp
new file mode 100644
index 0000000..21eed26
--- /dev/null
+++ b/1022.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <vector>
+#include <map>
+#include <string>
+#include <algorithm>
+#include <sstream>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	scanf("%d", &n);
+	getchar();
+	map<string, vector<string> > m[5];
+	string id;
+	string title, name, keyword, publisher, year;
+	for(int i = 0; i < n; ++i) {
+		getline(cin, id);
+		// cout << c << "--------------------_>" << id << endl;
+		for(int j = 0; j < 5; ++j) {
+			string tmpStr;
+			getline(cin, tmpStr);
+			if(2 != j)
+				m[j][tmpStr].push_back(id);
+			else {
+				istringstream istr(tmpStr);
+				while(!istr.eof()) {
+					string keyword;
+					istr >> keyword;
+					m[j][keyword].push_back(id);
+				}
+			}
+		}
+	}
+	map<string, vector<string> >::iterator iter;
+	for(int i = 0; i < 5; ++i) {
+		for(iter = m[i].begin(); iter != m[i].end(); ++iter) {
+			sort((iter->second).begin(), (iter->second).end());
+		}
+	}
+
+	cin >> n;
+	getchar();
+	for(int i = 0; i < n; ++i) {
+		string query;
+		int index;
+		scanf("%d: ", &index);
+		getline(cin, query);
+		printf("%d: ", index);
+		--index;
+		cout << query << endl;
+		iter = m[index].find(query);
+		if(m[index].end() != iter) {
+			for(int k = 0; k < (iter->second).size(); ++k) {
+				cout << (iter->second)[k] << endl;
+			}
+		}
+		else {
+			cout << "Not Found" << endl;
+		}
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/1023.cpp b/1023.cpp
new file mode 100644
index 0000000..e47e1b1
--- /dev/null
+++ b/1023.cpp
@@ -0,0 +1,58 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <cstring>
+
+using namespace std;
+
+void bigPlus(string a, string b, vector<int> &result) {
+	if(a.size() < b.size())
+		swap(a, b);
+	int t = 0;
+	int sum;
+	for(int i = a.size()-1; i >= 0 ; --i) {
+		sum = a[i] - '0' + b[i] - '0' + t;
+		result.push_back(sum % 10);
+		t = sum / 10;
+	}
+	if(0 != t) {
+		result.push_back(t);
+	}
+}
+
+int main(int argc, char const *argv[])
+{
+	string num;
+	cin >> num;
+	vector<int> result;
+	bigPlus(num, num, result);
+	int a[10];
+	int b[10];
+	memset(a, 0, sizeof(a));
+	memset(b, 0, sizeof(b));
+	for(int i = 0; i < num.size(); ++i) {
+		++a[num[i] - '0'];
+	}
+	for(int i = 0; i < result.size(); ++i) {
+		++b[result[i]];
+	}
+	bool isEqual = true;
+	for(int i = 0; i < 10; ++i) {
+		if(a[i] != b[i]) {
+			isEqual = false;
+			break;
+		}
+	}
+	if(isEqual) {
+		cout << "Yes" << endl;
+	}
+	else {
+		cout << "No" << endl;
+	}
+
+	for(int i = result.size()-1; i >= 0; --i) {
+		cout << result[i];
+	}
+	cout << endl;
+	return 0;
+}
\ No newline at end of file
diff --git a/1024.cpp b/1024.cpp
new file mode 100644
index 0000000..07f64fe
--- /dev/null
+++ b/1024.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <string>
+#include <cstdlib>
+#include <cstdio>
+#include <sstream>
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+typedef long long lint;
+
+bool isPalind(string s) {
+	for(int i = 0, j = s.size()-1; i < j; ++i, --j){
+		if(s[i] != s[j])
+			return false;
+	}
+	return true;
+}
+
+string bigPlus(string a, string b) {
+	string result = "";
+	vector<int> v;
+	for(unsigned int i = 0; i < a.size(); ++i) {
+		v.push_back(a[i] - '0' + b[i] - '0');
+	}
+	int borrow = 0;
+	for(int i = v.size()-1; i >= 0; --i) {
+		v[i] += borrow;
+		borrow = v[i] / 10;
+		result.push_back('0' + v[i] % 10);
+	}
+	if(0 != borrow)
+		result.push_back('0' + borrow);
+	reverse(result.begin(), result.end());
+	return result;
+}
+
+int main(int argc, char const *argv[])
+{
+	string a;
+	int k;
+	cin >> a >> k;
+	int i = 0;
+	for(; i < k; ++i) {
+		if(isPalind(a)) {
+			break;
+		}
+		string b = a;
+		reverse(b.begin(), b.end());
+		a = bigPlus(a, b);
+	} 	
+	cout << a << endl;
+	cout << i << endl; 
+	return 0;
+}
diff --git a/1025.cpp b/1025.cpp
new file mode 100644
index 0000000..0b4657d
--- /dev/null
+++ b/1025.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+using namespace std;
+
+class Test {
+public:
+	string _id;
+	int _score;
+	int _finalRank;
+	int _location;
+	int _localRank;
+};
+
+bool cmp(const Test &rhs, const Test &lhs) {
+	if(rhs._score != lhs._score)
+		return rhs._score > lhs._score;
+	else
+		return rhs._id < lhs._id;
+}
+
+int main(int argc, char*argv[]) {
+	int N;
+	scanf("%d", &N);
+	vector< vector<Test> > all;
+	for(int i = 0; i < N; ++i) {
+		int M;
+		scanf("%d", &M);
+		Test tmp;
+		tmp._location = i + 1;
+		vector<Test> a;
+		for(int j = 0; j < M; ++j) { 
+			cin >> tmp._id >> tmp._score;
+			a.push_back(tmp);
+		}
+		all.push_back(a);
+	}
+	
+	vector<Test> result;
+	for(int i = 0; i < N; ++i) {
+		if(0 == all[i].size())
+			continue;
+		sort(all[i].begin(), all[i].end(), cmp);
+		int curRank = 1, curSore = all[i][0]._score, curNum = 0;
+		for(int j = 0; j < all[i].size(); ++j) {
+			if(all[i][j]._score == curSore) {
+				all[i][j]._localRank = curRank;
+				++curNum;
+			}
+			else {
+				curRank += curNum;
+				curNum = 1;
+				all[i][j]._localRank = curRank; 
+				curSore = all[i][j]._score;
+			}
+			result.push_back(all[i][j]);
+		}
+	}
+	printf("%d\n", result.size());
+	sort(result.begin(), result.end(), cmp);
+	int curRank = 1, curSore = result[0]._score, curNum = 0;
+	for(int i = 0; i < result.size(); ++i ) {
+		if(result[i]._score == curSore) {
+			result[i]._finalRank = curRank;
+			++curNum;
+		}
+		else {
+			curRank += curNum;
+			curNum = 1;
+			result[i]._finalRank = curRank;
+			curSore = result[i]._score;
+		}
+		cout << result[i]._id;
+		printf(" %d %d %d\n", result[i]._finalRank, result[i]._location, result[i]._localRank);
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1027.cpp b/1027.cpp
new file mode 100644
index 0000000..a089b6e
--- /dev/null
+++ b/1027.cpp
@@ -0,0 +1,32 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int ce[3];
+	cin >> ce[0] >> ce[1] >> ce[2];
+	int cm[3][2];
+	for(int i = 0; i < 3; ++i) {
+		cm[i][0] = ce[i] / 13;
+		cm[i][1] = ce[i] % 13;
+	}
+	cout << "#";
+	char tmp;
+	for(int i = 0; i < 3; ++i) {
+		for(int j = 0; j < 2; ++j) {
+			if(cm[i][j] > 9) {
+				tmp = 'A' + cm[i][j] - 10;
+				cout << tmp;
+			}
+			else {
+				cout << cm[i][j];
+			}
+		}
+	}
+	cout << endl;
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1029.cpp b/1029.cpp
new file mode 100644
index 0000000..a69ae75
--- /dev/null
+++ b/1029.cpp
@@ -0,0 +1,79 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+typedef long long lint;
+
+vector<lint> v1;
+vector<lint> v2;
+
+int main(int argc, char *argv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+
+	int n1;
+	scanf("%d", &n1);
+	v1.resize(n1);
+	for(int i = 0; i < n1; ++i)
+		scanf("%lld", &v1[i]);
+	int n2;
+	scanf("%d", &n2);
+	v2.resize(n2);
+	for(int i = 0; i < n2; ++i)
+		scanf("%lld", &v2[i]);
+
+	// special case: 0
+	if(n1 <= 0 || n2 <= 0) {
+		if(n1 <= 0 && n2 <= 0)
+			printf("0\n");
+		else if(n1 <= 0)
+			printf("%d\n", v2[ (n2 - 1) / 2 ]);
+		else 
+			printf("%d\n", v1[ (n1 - 1) / 2 ]);
+		return 0;
+	}	
+
+	int midPos = (n1 + n2 - 1) / 2;
+	lint minM = min(v1[ (n1 - 1) / 2 ],  v2[ (n2 - 1) / 2 ] );
+	lint maxM = max(v1[ (n1 - 1) / 2 ],  v2[ (n2 - 1) / 2 ] );
+
+	while(minM <= maxM) {
+		if(minM == maxM) {
+			cout << minM << endl;
+			return 0;
+		}
+
+		lint m = (maxM - minM) / 2 + minM;
+		int numL = lower_bound(v1.begin(), v1.end(), m) - v1.begin() + lower_bound(v2.begin(), v2.end(), m) - v2.begin();
+		int numR = upper_bound(v1.begin(), v1.end(), m) - v1.begin() + upper_bound(v2.begin(), v2.end(), m) - v2.begin();
+		if(numL <= midPos && numR > midPos) {
+			cout << m << endl;
+			return 0;
+		}
+		else {
+			if(numL > midPos) 
+				maxM = m - 1;
+			else
+				minM = m + 1;
+		}
+	}
+
+
+	lint m = minM;
+	int numL = lower_bound(v1.begin(), v1.end(), m) - v1.begin() + lower_bound(v2.begin(), v2.end(), m) - v2.begin();
+	int numR = upper_bound(v1.begin(), v1.end(), m) - v1.begin() + upper_bound(v2.begin(), v2.end(), m) - v2.begin();
+	if(numL <= midPos && numR > midPos) {
+		cout << m << endl;
+		return 0;
+	}
+	cout << maxM << endl;
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1030.cpp b/1030.cpp
new file mode 100644
index 0000000..4a7d4ee
--- /dev/null
+++ b/1030.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+#include <stack>
+
+using namespace std;
+
+const int INF = 0x6fffffff;
+
+int main(int argc, char* argv[]) {
+	int N, M, S, D;
+	cin >> N >> M >> S >> D;
+	vector<int> d(N, INF);
+	vector<int> c(N, INF);
+	d[S] = 0;
+	c[S] = 0;
+	vector< vector<int> > weight(N, vector<int>(N, INF));
+	vector< vector<int> > cost(N, vector<int>(N, INF));
+	for(int i = 0; i < N; ++i) {
+		weight[i][i] = 0;
+		cost[i][i] = 0;
+	}
+	vector<int> pre(N, 0);
+	pre[S] = S;
+	int a, b, tmpW, tmpC;
+	for(int i = 0; i < M; ++i) {
+		scanf("%d%d%d%d", &a, &b, &tmpW, &tmpC);
+		weight[a][b] = weight[b][a] = tmpW;
+		cost[a][b] = cost[b][a] = tmpC;
+	}
+
+	vector<int> v(N, 0);
+	for(int i = 0; i < N; ++i) {
+		int x, y = INF;
+		for(int j = 0; j < N; ++j) {
+			if(0 == v[j] && d[j] < y) {
+				y = d[j];
+				x = j;
+			}
+		}
+		v[x] = 1;
+		for(int j = 0; j < N; ++j) {
+			if(d[x] + weight[x][j] < d[j]) {
+				d[j] = d[x] + weight[x][j];
+				pre[j] = x;
+				c[j] = c[x] + cost[x][j];
+
+				// printf("x:%d j:%d c[j]:%d", x, j, c[j]);	
+			}
+			if(d[x] + weight[x][j] == d[j] && c[x] + cost[x][j] < c[j]) {
+				pre[j] = x;
+				c[j] = c[x] + cost[x][j];
+
+				// printf("x:%d j:%d c[j]:%d", x, j, c[j]);
+			}
+		}
+	}
+
+	stack<int> s;
+	int cur = D;
+
+	while(pre[cur] != cur) {
+		s.push(cur);
+		cur = pre[cur];
+	}
+	s.push(cur);
+
+	while(!s.empty()) {
+		printf("%d ", s.top());
+		s.pop();
+	}
+	printf("%d %d\n", d[D], c[D]);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1031.cpp b/1031.cpp
new file mode 100644
index 0000000..8d5fc88
--- /dev/null
+++ b/1031.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <string>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	string s;
+	cin >> s;
+	int n1, n2, N = s.size(), maxn1 = 0;
+	for(n2 = 3; n2 <= N; ++n2) {
+		if((N+2-n2)&1)
+			continue;
+		else{
+			n1 = (N+2-n2)/2;
+			if(n2 >= n1 && n1 > maxn1)
+				maxn1 = n1;
+		}
+	}
+	n1 = maxn1;
+	n2 = N+2-2*maxn1;
+	for(int i = 0; i < n1-1; ++i) {
+		printf("%c", s[i]);
+		for(int j = 0; j < n2-2; ++j)
+			printf(" ");
+		printf("%c\n", s[N-1-i]);
+	}
+	for(int i = maxn1-1; i < n1 + n2 -1; ++i)
+		printf("%c", s[i]);
+	printf("\n");
+	return 0;
+}
\ No newline at end of file
diff --git a/1032.cpp b/1032.cpp
new file mode 100644
index 0000000..940d54d
--- /dev/null
+++ b/1032.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cstring>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int m[100010];
+	memset(m, 0, sizeof(m));
+	int root1, root2, n;
+	cin >> root1 >> root2 >> n;
+	if(root1 == -1 || root2 == -1){
+		cout << -1 << endl;
+		return 0;
+	}
+
+	char tmp;
+	int adr, next;
+	for(int i = 0; i < n; ++i) {
+		cin >> adr >> tmp >> next;
+		m[adr] = next; 
+	}
+	// vector<int> v;
+	int m1[100010];
+	memset(m1, 0, sizeof(m1));
+	int cur = root1;
+	while(cur != -1) {
+		m1[cur] = 1;
+		cur = m[cur];
+	}
+
+	int result = -1;
+	cur = root2;
+	while(cur != -1) {
+		if(m1[cur] == 1) {
+			result = cur;
+			break;
+		}
+		cur = m[cur];
+	}
+	if(-1 != result)
+		printf("%.05d\n", result);
+	else
+		cout << result << endl;
+	return 0;
+}
\ No newline at end of file
diff --git a/1035.cpp b/1035.cpp
new file mode 100644
index 0000000..0dc5402
--- /dev/null
+++ b/1035.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	// vector<pair<string, string> > ori;
+	vector<pair<string, string> > v;
+	int n;
+	cin >> n;
+	string id, pword;
+	bool flag = false;
+	for(int i = 0; i < n; ++i) {
+		flag = false;
+		cin >> id >> pword;
+		for(int j = 0; j < pword.size(); ++j) {
+			if(pword[j] == '1')
+				pword[j] = '@';
+			else if(pword[j] == '0')
+				pword[j] = '%';
+			else if(pword[j] == 'l')
+				pword[j] = 'L';
+			else if(pword[j] == 'O')
+				pword[j] = 'o';
+			else
+				continue;
+			flag = true;
+		}
+		if(flag)
+			v.push_back(pair<string, string>(id, pword));
+	}
+
+	if(0 == v.size()) {
+		if(1 == n) {
+			cout << "There is 1 account and no account is modified" << endl;
+		}
+		else {
+			cout << "There are " << n << " accounts and no account is modified" << endl;
+		}
+	}
+	else {
+		cout << v.size() << endl;
+		for(int i = 0; i < v.size(); ++i) {
+			cout << v[i].first << " " << v[i].second << endl;
+		}
+	}
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1036.cpp b/1036.cpp
new file mode 100644
index 0000000..e7c5d6b
--- /dev/null
+++ b/1036.cpp
@@ -0,0 +1,58 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+class Student{
+public:
+	string name;
+	string id;
+	int score;
+};
+
+int main(int argc, char const *argv[])
+{
+
+	Student maxF, minM;
+	maxF.score = -1;
+	minM.score = 9999;
+	int n;
+	Student tmp;
+	char sex;
+	cin >> n;
+	for(int i = 0; i < n; ++i) {
+		cin >> tmp.name >> sex >> tmp.id >> tmp.score;
+		if(sex == 'M') {
+			if(tmp.score < minM.score) {
+				minM = tmp;
+			}
+		}
+		else {
+			if(tmp.score > maxF.score) {
+				maxF = tmp;
+			}
+		}
+	}
+	if(maxF.score == -1) {
+		cout << "Absent" << endl;
+	}
+	else {
+		cout << maxF.name << " " << maxF.id << endl;
+	}
+
+	if(minM.score == 9999) {
+		cout << "Absent" << endl;
+	}
+	else {
+		cout << minM.name << " " << minM.id << endl;
+	}
+
+	if(maxF.score != -1 && minM.score != 9999) {
+		cout << maxF.score - minM.score << endl;
+	}
+	else {
+		cout << "NA" << endl;
+	}
+	
+	return 0;
+}
\ No newline at end of file
diff --git a/1037.cpp b/1037.cpp
new file mode 100644
index 0000000..8619195
--- /dev/null
+++ b/1037.cpp
@@ -0,0 +1,54 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+bool cmp(const int a, const int b) {
+	return a > b;
+}
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	cin >> n;
+	vector<int> pc;
+	vector<int> nc;
+	vector<int> pp;
+	vector<int> np;
+	int tmp;
+	for(int i = 0; i < n; ++i) {
+		cin >> tmp;
+		if(tmp > 0) {
+			pc.push_back(tmp);
+		}
+		else if(tmp < 0) {
+			nc.push_back(-tmp);
+		}
+	}
+	cin >> n;
+	for(int i = 0; i < n; ++i) {
+		cin >> tmp;
+		if(tmp > 0) {
+			pp.push_back(tmp);
+		}
+		else if(tmp < 0) 
+			np.push_back(-tmp);
+	}
+
+	sort(pc.begin(), pc.end(), cmp);
+	sort(nc.begin(), nc.end(), cmp);
+	sort(pp.begin(), pp.end(), cmp);
+	sort(np.begin(), np.end(), cmp);
+
+	int result = 0;
+	for(int i = 0, j = 0; i < pc.size() && j < pp.size(); ++i, ++j) {
+		result += pc[i] * pp[j];
+	}
+	for(int i = 0, j = 0; i < nc.size() && j < np.size(); ++i, ++j) {
+		result += nc[i] * np[j];
+	}
+
+	cout << result << endl;
+	return 0;
+}
\ No newline at end of file
diff --git a/1039.cpp b/1039.cpp
new file mode 100644
index 0000000..a528ffb
--- /dev/null
+++ b/1039.cpp
@@ -0,0 +1,31 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <map>
+#include <vector>
+
+using namespace std;
+
+int main(int argc, char *argv) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+
+	int N, K;
+	scanf("%d%d", &N, &K);
+	int courseId, registNum;
+	char tmpName[5];
+	
+	for(int i =0; i < K; ++i) {
+		scanf("%d", &N);
+		scanf("")
+
+	}
+
+
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1040.cpp b/1040.cpp
new file mode 100644
index 0000000..d98855c
--- /dev/null
+++ b/1040.cpp
@@ -0,0 +1,32 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	char str[1100];
+	cin.getline(str, 1010);
+	string s = str;
+	int result = 1;
+	const int n = s.size();
+	vector<bool>  f(n, false);
+	for(int i = n-1; i >= 0; --i) {
+		f[i] = true;
+		for(int j = n-1; j >= i+1; --j) {
+			if(i + 1 == j) {
+				f[j] = (s[i] == s[j]);
+			}
+			else {
+				f[j] = (s[i] == s[j]) && f[j-1];
+			}
+			if(f[j] && j-i+1 > result) {
+				result = j-i+1;
+			}
+		}
+	}
+	cout << result << endl;
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1042.cpp b/1042.cpp
new file mode 100644
index 0000000..5d61f95
--- /dev/null
+++ b/1042.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+using namespace std;
+
+int main(int argc, char *argv[]) {
+	vector<string> v;
+	v.push_back("");
+	vector<string> s4(4);
+	s4[0] = "S";
+	s4[1] = "H";
+	s4[2] = "C";
+	s4[3] = "D";
+	for(int k = 0; k < 4; ++k) {
+		for(int i = 1; i <= 13; ++i) {
+			string s = s4[k];
+			if(i < 10)
+				s.push_back('0' + i);
+			else {
+				s.push_back('0' + i / 10);
+				s.push_back('0' + i % 10);
+			}
+			v.push_back(s);
+		}
+	}
+	v.push_back("J1");
+	v.push_back("J2");
+
+	// for(int i = 1; i <= 54; ++i) {
+	// 	cout << v[i] << " ";
+	// }
+
+	int n;
+	scanf("%d", &n);
+
+	int a[55];
+	int b[55];
+	int c[55];
+	memset(a, 0, sizeof(a));
+	memset(b, 0, sizeof(b));
+	memset(c, 0, sizeof(c));
+	for(int i = 1; i <= 54; ++i) {
+		scanf("%d", &a[i]);
+		b[i] = i;
+	}
+
+	for(int k = 0; k < n; ++k) {
+		for(int i = 1; i <= 54; ++i) {
+			c[ a[i] ] = b[i];
+		}
+		for(int i = 1; i <= 54; ++i) {
+			b[i] = c[i];
+		}
+	}
+
+	cout << v[ b[1] ];
+	for(int i = 2; i <= 54; ++i) {
+		cout << " " << v[ b[i] ];
+	}
+	cout << endl;
+	return 0;
+}
diff --git a/1043.cpp b/1043.cpp
new file mode 100644
index 0000000..ad53d62
--- /dev/null
+++ b/1043.cpp
@@ -0,0 +1,113 @@
+#include <iostream>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+typedef vector<int>::iterator Iter;
+
+struct Node {
+	int val;
+	Node* left;
+	Node* right;
+};
+
+Node* returnRoot1(Iter lhs, Iter rhs, bool &isVal) {
+	if(lhs >= rhs)
+		return NULL;
+	Node* root = new Node;
+	root->val = *lhs;
+	Iter it = lhs + 1;
+	for(; it != rhs; ++it) {
+		if(*it >= *lhs)
+			break;
+	}
+	Iter breakPos = it;
+	for(; it != rhs; ++it) {
+		if(*it < *lhs) {
+			isVal = false;
+			delete root;
+			return NULL;
+		}
+	}
+	root->left = returnRoot1(lhs+1, breakPos, isVal);
+	root->right = returnRoot1(breakPos, rhs, isVal);
+	return root;
+}
+
+Node* returnRoot2(Iter lhs, Iter rhs, bool &isVal) {
+	if(lhs >= rhs)
+		return NULL;
+	Node* root = new Node;
+	root->val = *lhs;
+	Iter it = lhs + 1;
+	for(; it != rhs; ++it) {
+		if(*it < *lhs)
+			break;
+	}
+	Iter breakPos = it;
+	for(; it != rhs; ++it) {
+		if(*it >= *lhs) {
+			isVal = false;
+			delete root;
+			return NULL;
+		}
+	}
+	root->left = returnRoot2(lhs+1, breakPos, isVal);
+	root->right = returnRoot2(breakPos, rhs, isVal);
+	return root;
+}
+
+void printPos(Node *root, vector<int> &v) {
+	if(root == NULL)
+		return;
+	printPos(root->left, v);
+	printPos(root->right, v);
+	v.push_back(root->val);
+}
+
+void printfV(const vector<int> &v) {
+	if(v.size() == 0)
+		return;
+	printf("YES\n");
+	printf("%d", v[0]);
+	for(int i = 1; i < v.size(); ++i)
+		printf(" %d", v[i]);
+	printf("\n");
+}
+
+int main(int argc, char*argv[]) {
+	int N;
+	scanf("%d", &N);
+	vector<int> ori(N, 0);
+	for(int i = 0; i < N; ++i)
+		scanf("%d", &ori[i]);
+	if(0 == N) {
+		printf("NO\n");
+		return 0;
+	}
+
+	bool isBST = true;
+	Node* root1 = returnRoot1(ori.begin(), ori.end(), isBST);
+
+	if(isBST) {
+		vector<int> v;
+		printPos(root1, v);
+		printfV(v);
+	}
+	else {
+		bool isM = true;
+		Node *root2 = returnRoot2(ori.begin(), ori.end(), isM);
+		if(isM) {
+			vector<int> v;
+			printPos(root2, v);
+			printfV(v);
+		}
+		else {
+			printf("NO\n");
+		}
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1044.cpp b/1044.cpp
new file mode 100644
index 0000000..4ebe636
--- /dev/null
+++ b/1044.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+class Pay{
+public:
+	int lhs;
+	int rhs;
+	int sum;
+	bool operator < (const Pay &a) const {
+		return lhs < a.lhs;
+	}
+};
+//
+//bool cmp(const Pay &i, const Pay &j) {
+//	return i.lhs < j.lhs;
+//}
+
+int main(int argc, char *argv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+	int N, M;
+	scanf("%d%d", &N, &M);
+	vector<int> v(N, 0);
+	for(int i = 0; i < N; ++i)
+		scanf("%d", &v[i]);
+	if(N <= 0)
+		return 0;
+	vector<Pay> result;
+	for(int i = 0; i < N; ++i) {
+		bool isSmall = true;
+		Pay tmp;
+		int sum = 0;
+		for(int j = i; j < N; ++j) {
+			if(!isSmall)
+				break;
+			sum += v[j];
+			if(sum >= M) {
+				tmp.lhs = i + 1;
+				tmp.rhs = j + 1;
+				tmp.sum = sum - M;
+				result.push_back(tmp);
+				isSmall = false;
+			}
+
+		}
+		if(isSmall)
+			break;
+	}
+	
+	if(0 == result.size())
+		return 0;
+	int gap = result[0].sum;
+	for(int i = 0; i < result.size(); ++i) {
+		if(result[i].sum < gap)
+			gap = result[i].sum;
+	}
+	vector<Pay> f;
+	for(int i = 0; i < result.size(); ++i) {
+		if(gap == result[i].sum)
+			f.push_back(result[i]);
+	}
+	
+	sort(f.begin(), f.end());
+
+	for(int i = 0; i < f.size(); ++i)
+		printf("%d-%d\n", f[i].lhs, f[i].rhs);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1045.cpp b/1045.cpp
new file mode 100644
index 0000000..71f1460
--- /dev/null
+++ b/1045.cpp
@@ -0,0 +1,86 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+struct Node
+{
+	int _val;
+	int _num;
+};
+
+int main(int argc, char*argv[]) {
+	int N, M;
+	scanf("%d%d", &N, &M);
+	vector<int> favor(M, 0);
+	vector<int> inFavor(N+1, 0);
+	int tmp;
+	for(int i = 0; i < M; ++i) {
+		scanf("%d", &tmp);
+		inFavor[tmp] = 1;
+		favor[i] = tmp;
+	}
+	vector<int> stripe;
+	int num;
+	scanf("%d", &num);
+	for(int i = 0; i < num; ++i) {
+		scanf("%d", &tmp);
+		if(1 == inFavor[tmp]) {
+			stripe.push_back(tmp);
+		}
+	}
+
+	if(0 == stripe.size() || 0 == favor.size()) {
+		printf("0\n");
+		return 0;
+	}
+
+	Node node;
+	node._val = stripe[0];
+	node._num = 0;
+	vector<Node> stripes;
+	for(int i = 0; i < stripe.size(); ++i) {
+		if(stripe[i] == node._val) {
+			node._num += 1;
+		}
+		else {
+			stripes.push_back(node);
+			node._val = stripe[i];
+			node._num = 1;
+		}
+	}
+	stripes.push_back(node);
+
+	vector<int> replaceTable(N+1, 0);
+	for(int i = 0; i < favor.size(); ++i) {
+		replaceTable[ favor[i] ] = i;
+	}
+
+	for(int i = 0; i < stripes.size(); ++i)
+		stripes[i]._val = replaceTable[ stripes[i]._val ];
+
+	vector<int> f(stripes.size(), 0);
+	f[0] = stripes[0]._num;
+	for(int i = 1; i < stripes.size(); ++i) {
+		f[i] = stripes[i]._num;
+		for(int j = 0; j < i; ++j) {
+			if(stripes[j]._val <= stripes[i]._val)
+				f[i] = max(f[i], f[j] + stripes[i]._num);
+		}
+	}
+
+	int maxLen = f[0];
+	for(int i = 0; i < f.size(); ++i)
+		if(f[i] > maxLen)
+			maxLen = f[i];
+
+	printf("%d\n", maxLen);
+
+	// int maxLen = 0, curLen = 0, curS = 0, curF = 0;
+	// dfs(stripes, favor, maxLen, curLen, curS, curF, remain);
+	// printf("%d\n", maxLen);
+	return 0;
+}
\ No newline at end of file
diff --git a/1046.cpp b/1046.cpp
new file mode 100644
index 0000000..cf527b3
--- /dev/null
+++ b/1046.cpp
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <vector>
+#include <cstdio>
+#include <algorithm>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	scanf("%d", &n);
+	vector<int> v(n, 0);
+	for(int i = 1; i < n; ++i) {
+		scanf("%d", &v[i]);
+		v[i] += v[i-1];
+	}
+	int total;
+	scanf("%d", &total);
+	total += v[n-1];
+
+	scanf("%d", &n);
+	int a, b;
+	int tmp;
+
+	for(int i = 0; i < n; ++i) {
+		scanf("%d%d", &a, &b);
+		if(a > b)
+			swap(a, b);
+		tmp = v[b-1] - v[a-1];
+		// printf("%d %d\n", v[a-1], v[b-1]);
+		tmp = min(tmp, total - tmp);
+		printf("%d\n", tmp);
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1047.cpp b/1047.cpp
new file mode 100644
index 0000000..b2391cd
--- /dev/null
+++ b/1047.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+using namespace std;
+
+vector< vector<string> > v;
+vector<string> names;
+
+int main(int argc, char *argv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+	
+	int N, K;
+	scanf("%d%d", &N, &K);
+	for(int i = 0; i < K; ++i) {
+		vector<string> tmp;
+		v.push_back(tmp);
+	}
+	for(int i = 0; i < N; ++i) {
+		string name;
+		int n, course;
+		cin >> name >> n;
+		names.push_back(name);
+		for(int j = 0; j < n; ++j) {
+			cin >> course;
+			v[course - 1].push_back(name);
+		}
+	}
+	for(int i = 0; i < K; ++i) {
+		if(0 != v[i].size())
+			sort(v[i].begin(), v[i].end());
+		printf("%d %d\n", i + 1, v[i].size());
+		for(int j = 0; j < v[i].size(); ++j) {
+			cout << v[i][j];
+			printf("\n");
+		}
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1049.cpp b/1049.cpp
new file mode 100644
index 0000000..eb3a2a7
--- /dev/null
+++ b/1049.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	cin >> n;
+	int i = 1;
+	int cur, before, after;
+	int result = 0;
+	while( 0 != (n/i) ) {
+		cur = (n/i) % 10;
+		before = n / (i * 10);
+		after = n - n / (i) * i;
+
+		if(cur > 1) {
+			result += (before + 1) * i;
+		}
+		else if(cur == 1) {
+			result += before * i + (after + 1);
+		}
+		else if(cur < 1) {
+			result += before * i;
+		}
+		i *= 10;
+	}
+
+	cout << result << endl;
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1050.cpp b/1050.cpp
new file mode 100644
index 0000000..0318de6
--- /dev/null
+++ b/1050.cpp
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <string>
+#include <cstdio>
+#include <cstring>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int t[2000];
+	memset(t, 0, sizeof(t));
+	char str[11000];
+	cin.getline(str, 10010);
+	char s[11000];
+	cin.getline(s, 10010);
+	for(unsigned int i = 0; '\0' != s[i]; ++i) {
+		t[s[i]] = 1;
+	}
+	for(int i = 0; str[i] != '\0'; ++i) {
+		if(0 == t[str[i]])
+			printf("%c", str[i]);
+	}
+	printf("\n");
+	return 0;
+}
\ No newline at end of file
diff --git a/1051.cpp b/1051.cpp
new file mode 100644
index 0000000..762ba07
--- /dev/null
+++ b/1051.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <stack>
+#include <vector>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int m, n, k;
+	cin >> m >> n >> k;
+	for(int i = 0; i < k; ++i) {
+		stack<int> s1;
+		stack<int> s2;
+		vector<int> v;
+		int now;
+		for(int j = n; j > 0; --j){
+			scanf("%d", &now);
+			v.push_back(now);
+			s2.push(j);
+		}
+		bool posible = true;
+		for(int j = 0; j < n; ++j){
+			if(false == posible)
+				break;
+			if(s1.empty() || s1.top() < v[j]) {
+				while(true) {
+					// cout << "here 1" << endl;
+					if(s2.empty() || s2.top() > v[j]) {
+						// cout << s2.top() << " " << v[j] << endl;
+						posible = false;
+						// cout << "here 3" << endl;
+						break;
+					}
+					s1.push(s2.top());
+					// cout << s2.top() << endl;
+					s2.pop();
+					if(s1.top() == v[j]) {
+						// cout << "here 2" << endl;
+						break;
+					}
+				}
+				if(s1.size() > m) {
+					posible = false;
+				}
+				else {
+					s1.pop();
+				}
+			}
+			else {
+				if(s1.top() == v[j]) {
+					s1.pop();
+				}
+				else {
+					posible = false;
+				}
+			}	
+		}
+
+		if(posible) {
+			cout << "YES" << endl;
+		}
+		else {
+			cout << "NO" << endl;
+		}
+
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1052.cpp b/1052.cpp
new file mode 100644
index 0000000..207c7d1
--- /dev/null
+++ b/1052.cpp
@@ -0,0 +1,49 @@
+#include <vector>
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+
+using namespace std;
+
+class Node
+{
+public:
+	int val;
+	int adr;
+	int next;
+	bool operator < (const Node &rhs) const {
+		return val < rhs.val;
+	}
+};
+
+int main(int argc, char const *argv[])
+{
+	int n, root;
+	cin >> n >> root;
+	vector<Node> v;
+	Node node;
+	Node m[100010];
+	for(int i = 0; i < n; ++i) {
+		cin >> node.adr >> node.val >> node.next;
+		if(node.adr < 0)
+			continue;
+		m[node.adr] = node;
+	}
+	int cur = root;
+	while(cur != -1) {
+		v.push_back(m[cur]);
+		cur = m[cur].next;
+	}
+	sort(v.begin(), v.end());
+	if(v.size() == 0) {
+		printf("0 -1\n");
+		return 0;
+	}
+	cout << v.size() << " ";
+	printf("%.05d\n", v[0].adr);
+	for(int i = 0; i < v.size() - 1; ++i) {
+		printf("%.05d %d %.05d\n", v[i].adr, v[i].val, v[i+1].adr);
+	}
+	printf("%.05d %d -1\n", v[v.size()-1].adr, v[v.size()-1].val);
+	return 0;
+}
\ No newline at end of file
diff --git a/1053.cpp b/1053.cpp
new file mode 100644
index 0000000..88e9d3d
--- /dev/null
+++ b/1053.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+bool cmp(const vector<int> &lhs, const vector<int> &rhs) {
+	int i = 0;
+	for(; i < lhs.size() && i < rhs.size(); ++i) {
+		if(lhs[i] != rhs[i])
+			return lhs[i] > rhs[i];
+	}
+	if(i == lhs.size() || i == rhs.size())
+		return lhs.size() > rhs.size();
+}
+
+int main(int argc, char* argv[]) {
+	int N, M, S;
+	scanf("%d%d%d", &N, &M, &S);
+	vector<int> weight(N, 0);
+	for(int i = 0; i < N; ++i)
+		scanf("%d", &weight[i]);
+	vector<int> pre(N, 0);
+	vector<int> isLeaf(N, 1);
+	for(int i = 0; i < M; ++i) {
+		int preNode, k;
+		scanf("%d%d", &preNode, &k);
+		isLeaf[preNode] = 0;
+		int curNode;
+		for(int j = 0; j < k; ++j) {
+			scanf("%d", &curNode);
+			pre[curNode] = preNode;
+		}
+	}
+	vector< vector<int> > paths;
+	for(int i = 0; i < N; ++i) {
+		if(0 == isLeaf[i])
+			continue;
+		int cur = i, sum = 0;
+		bool cut = false;
+		vector<int> path;
+		path.clear();
+		while(cur != pre[cur]) {
+			sum += weight[cur];
+			path.push_back(weight[cur]);
+			cur = pre[cur];
+			if(sum > S) {
+				cut = true;
+				break;
+			}
+		}
+		if(false == cut && sum + weight[cur] == S) {
+			path.push_back(weight[cur]);
+			reverse(path.begin(), path.end());
+			paths.push_back(path);
+		}
+	}
+
+	sort(paths.begin(), paths.end(), cmp);
+
+	for(int i = 0; i < paths.size(); ++i) {
+		printf("%d", paths[i][0]);
+		for(int j = 1; j < paths[i].size(); ++j) {
+			printf(" %d", paths[i][j]);
+		}
+		printf("\n");
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1054.cpp b/1054.cpp
new file mode 100644
index 0000000..77d5b4e
--- /dev/null
+++ b/1054.cpp
@@ -0,0 +1,32 @@
+#include <map>
+#include <cstdio>
+#include <iostream>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	// printf("here0\n");
+	int m1, n;
+	scanf("%d%d", &m1, &n);
+	int tmp;
+	map<int, int> m;
+	// printf("here1\n");
+	for(int i = 0; i < n; ++i) {
+		for(int j = 0; j < m1; ++j) {
+			scanf("%d", &tmp);
+			// printf("here2\n");
+			m[tmp] += 1;
+		}
+	}
+	map<int, int>::iterator iter;
+	int maxN = -1, result = 0;
+	for(iter = m.begin(); iter != m.end(); ++iter) {
+		if(iter->second > maxN) {
+			result = iter->first;
+			maxN = iter->second;
+		}
+	}
+	printf("%d\n", result);
+	return 0;
+}
\ No newline at end of file
diff --git a/1056.cpp b/1056.cpp
new file mode 100644
index 0000000..a7dd4f8
--- /dev/null
+++ b/1056.cpp
@@ -0,0 +1,83 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int np, ng;
+	scanf("%d%d", &np, &ng);
+	vector<int> w(np, 0);
+	for(int i = 0; i < np; ++i) {
+		scanf("%d", &w[i]);
+	}
+	vector<int> order(np, 0);
+	for(int i = 0; i < np; ++i) {
+		scanf("%d", &order[i]);
+	}
+	vector<vector<int> > v;
+	vector<int> tmp;
+	vector<int> lose;
+	while(1 != order.size()) {
+
+		tmp.clear();
+		lose.clear();
+
+		int i = 0;
+		for(; i <= int(order.size())-ng;) {
+			int max = -1, maxId = 0;
+			for(int j = i; j < i + ng; ++j) {
+				if(w[order[j]] > max) {
+					maxId = order[j];
+					max = w[order[j]];
+				}
+			}
+			tmp.push_back(maxId);
+			for(int j = i; j < i + ng; ++j) {
+				if(order[j] != maxId)
+					lose.push_back(order[j]);
+			}
+			i += ng;
+		}
+
+		if(i < order.size()) {
+			int max = -1, maxId = 0;
+			for(int j = i; j < order.size(); ++j) {
+				if(w[order[j]] > max) {
+					maxId = order[j];
+					max = w[order[j]];
+				}
+			}
+			tmp.push_back(maxId);
+			for(int j = i; j < order.size(); ++j) {
+				if(order[j] != maxId)
+					lose.push_back(order[j]);
+			}
+		}
+
+		v.push_back(lose);
+		order = tmp;
+	}	
+
+	v.push_back(vector<int>(1, order[0]));	
+	
+	vector<int> result(np, 0);
+	int rank = 1;
+	for(int i = v.size() - 1; i >= 0; --i) {
+		for(int j = v[i].size() - 1; j >= 0; --j) {
+			result[ v[i][j] ] = rank;
+		}
+		rank += v[i].size();
+	}
+
+	if(0 != result.size())
+		printf("%d", result[0]);
+	for(int i = 1; i < result.size(); ++i) {
+		printf(" %d", result[i]);
+	}
+	printf("\n");
+	
+	return 0;
+}
\ No newline at end of file
diff --git a/1057.cpp b/1057.cpp
new file mode 100644
index 0000000..8d7c0a9
--- /dev/null
+++ b/1057.cpp
@@ -0,0 +1,178 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <climits>
+#include <queue>
+#include <functional>
+#include <cstring>
+#include <stack>
+#include <set>
+
+multiset<int> s1;
+
+
+using namespace std;
+
+//  key is a positive integer no more than 10^5
+
+const int MAXNUM = 100000;
+
+const string pushStr = "Push";
+const string popStr = "Pop";
+const string midStr = "PeekMedian";
+
+int a[MAXNUM + 1];
+
+void update(int pos, int num) {
+	if(pos <= 0)
+		return;
+	while(pos <= MAXNUM) {
+		a[pos] += num;
+		pos += pos & (pos ^ (pos - 1));
+	}
+}
+
+int getSum(int pos) {
+	int result = 0;
+	while(pos > 0) {
+		result += a[pos];
+		pos -= pos & (pos ^ (pos - 1));
+	}
+	return result;
+}
+
+int getMid(int n) {
+	int midPos = (n - 1) / 2 + 1;
+	int left = 1;
+	int right = MAXNUM;
+	while(left <= right) {
+		if(left == right)
+			return left;
+		int mid = (right - left) / 2 + left;
+		if( getSum(mid) < midPos ) {
+			left = mid + 1;
+		}
+		else {
+			right = mid;
+		}
+	}
+}
+
+struct BinTree
+{
+    static const int MAXN = 100010;
+    vector<int> a;
+
+    BinTree()
+    {
+        a = vector<int>(MAXN,0);
+    }
+
+    int lowbit(int t)
+    {
+        return t&(-t);
+    }
+
+    void update(int t, int d)
+    {
+        while (t <= MAXN)
+        {
+            a[t] += d;
+            t += lowbit(t);
+        }
+    }
+
+    int getsum(int t)
+    {
+        int sum(0);
+        while (t > 0)
+        {
+            sum += a[t];
+            t -= lowbit(t);
+        }
+        return sum;
+    }
+    int find(int val, int l = 0, int h = MAXN - 1)
+    {
+        if (l == h)
+            return l;
+        int mid = (l + h) / 2;
+        if (getsum(mid) < val)
+        {
+            //return find(val, mid, h);
+            return find(val, mid + 1, h);
+        }
+        else
+        {
+            return find(val, l, mid);
+        }
+    }
+};
+BinTree tree;
+
+int main(int argc, char *argv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+
+	int N;
+	scanf("%d", &N);
+	int mid = 0;
+	stack<int> s;
+	string action;
+
+	char str[20];
+
+	
+
+	memset(a, 0, sizeof(a));
+
+	for(int k = 0; k < N; ++k) {
+		/*cin >> action;*/
+
+		scanf("%s", &str);
+
+		// push
+		if('u' == str[1]) {
+			int tmp;
+			scanf("%d", &tmp);
+			update(tmp, 1);
+			//tree.update(tmp, 1);
+
+			s.push(tmp);
+
+		}
+		// pop
+		else if('o' == str[1]) {
+			if(0 != s.size()) {
+				printf("%d\n", s.top());
+				update(s.top(), -1);
+				//tree.update(s.top(), -1);
+
+				s.pop();
+
+			}
+			else {
+				printf("Invalid\n");
+			}
+		}
+		// mid
+		else {
+			if(0 != s.size()) {
+				mid = getMid(s.size());
+				//mid = tree.find(  (s.size() + 1) / 2  );
+				printf("%d\n", mid);
+			}
+			else {
+				printf("Invalid\n");
+			}
+		}
+
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1058.cpp b/1058.cpp
new file mode 100644
index 0000000..4960aab
--- /dev/null
+++ b/1058.cpp
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+class Hog{
+public:
+	int a;
+	int b;
+	int c;
+};
+
+int main(int argc, char const *argv[])
+{
+	Hog A, B;
+	scanf("%d.%d.%d %d.%d.%d", &A.a, &A.b, &A.c, &B.a, &B.b, &B.c);
+	Hog C;
+	int t;
+	C.c = (A.c + B.c) % 29;
+	t = (A.c + B.c) / 29;
+	C.b = (A.b + B.b + t) % 17;
+	t = (A.b + B.b + t) / 17;
+	C.a = A.a + B.a + t;
+	printf("%d.%d.%d\n", C.a, C.b, C.c);
+	return 0;
+}
\ No newline at end of file
diff --git a/1059.cpp b/1059.cpp
new file mode 100644
index 0000000..a4a1d66
--- /dev/null
+++ b/1059.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+
+using namespace std;
+
+typedef unsigned long long lcc;
+
+struct Node {
+	lcc _factor;
+	lcc _time;
+	Node(lcc f, lcc t):_factor(f), _time(t){};
+};
+
+int main(int argc, char *argv[]) {
+	lcc N;
+	cin >> N;
+	lcc tmp = N;
+	if(1 == N) {
+		printf("1=1\n");
+		return 0;
+	}
+	cout << N << "=";
+	// const lcc bound = N;
+	const lcc bound = ceil(sqrt(tmp));
+	vector<bool> f(bound + 1, true);
+
+	f[0] = false;
+	f[1] = false;
+	// cout << ceil( sqrt(N) )<< endl;
+	for(lcc i = 2; i <= bound; ++i) {
+		if(false == f[i])
+			continue;
+		for(lcc j = i + i; j <= bound; j += i) {
+			f[j] = false;
+		}
+	}
+	
+	// cout << "here" << endl;
+
+	vector<lcc> primers;
+	for(lcc i = 2; i < f.size(); ++i) {
+		if(true == f[i])
+			primers.push_back(i);
+	}
+	lcc index = 0;
+	vector<Node> result;
+	while(1 != N && index < primers.size() && primers[index] <= ceil(sqrt(tmp)) ) {
+		// if(true == f[N]) {
+		// 	result.push_back( Node(N, 1) );
+		// 	break;
+		// }
+		int num = 0;
+		while(1 != N) {
+			if(N % primers[index] == 0) {
+				num++;
+				N /= primers[index];
+			}
+			else
+				break;
+		}
+		if(0 != num) {
+			result.push_back( Node(primers[index], num) );
+		}
+		++index;
+	}
+	if(true == f[N]) {
+		result.push_back( Node(N, 1) );
+	}
+	if(0 == result.size()) {
+		cout << N << endl;
+	}
+	else {
+		if(1 == result[0]._time ) {
+			cout << result[0]._factor;
+		}
+		else{
+			cout << result[0]._factor << "^" << result[0]._time;
+		}
+		for(int i = 1; i < result.size(); ++i) {
+			if(1 == result[i]._time)
+				cout << "*" << result[i]._factor;
+			else
+				cout << "*" << result[i]._factor << "^" << result[i]._time;
+		}
+		cout << endl;
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1060.cpp b/1060.cpp
new file mode 100644
index 0000000..6fb757c
--- /dev/null
+++ b/1060.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+void s2v(int N, vector<char> &vr, int &k, const string &s) {
+	k = -1;
+	vector<char> v;
+	int firstNoneZero = -1;
+	int dotPos = -1;
+	for(int i = 0; i < s.size(); ++i) {
+		if(s[i] == '.') {
+			dotPos = i;
+			break;
+		}
+	}
+	for(int i = 0; i < s.size(); ++i) {
+		if(s[i] != '0' && s[i] != '.') {
+			firstNoneZero = i;
+			break;
+		}
+	}
+
+	if(-1 != firstNoneZero){
+		if(-1 == dotPos) {
+			k = s.size() - firstNoneZero;
+			for(int i = firstNoneZero; i < s.size(); ++i)
+				v.push_back(s[i]);
+		}
+		else if(firstNoneZero > dotPos){
+			k = -(firstNoneZero - dotPos - 1);
+			for(int i = firstNoneZero; i< s.size(); ++i)
+				v.push_back(s[i]);
+		}
+		else {
+			k = dotPos - firstNoneZero;
+			for(int i = firstNoneZero; i < s.size(); ++i)
+				if('.' != s[i])
+					v.push_back(s[i]);
+		}
+	}
+	else {
+		k = 0;
+	}
+
+	if(v.size() < N) {
+		vr = v;
+		for(int i = 0; i < N-v.size(); ++i) {
+			vr.push_back('0');
+		}
+	}
+	else {
+		for(int i = 0; i < N; ++i) {
+			vr.push_back(v[i]);
+		}
+	}
+}
+
+void printfV(const vector<char> &v, int k) {
+	cout << "0.";
+	for(int i = 0; i < v.size(); ++i) {
+		cout << v[i];
+	}
+	cout << "*10^" << k;
+}
+
+int main(int argc, char const *argv[])
+{
+	int N;
+	cin >> N;
+	string s1, s2;
+	cin >> s1 >> s2;
+	int k1, k2;
+	vector<char> v1;
+	vector<char> v2;
+	s2v(N, v1, k1, s1);
+	s2v(N, v2, k2, s2);
+	if(k1 == k2 && v1 == v2) {
+		cout << "YES ";
+		printfV(v1, k1);
+		cout << endl;
+	}
+	else {
+		cout << "NO ";
+		printfV(v1, k1);
+		cout << " ";
+		printfV(v2, k2);
+		cout << endl;
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1061.cpp b/1061.cpp
new file mode 100644
index 0000000..2c04528
--- /dev/null
+++ b/1061.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <cstdio>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	cin >> n;
+	int tmp, tmpN;
+	vector<vector<int> > v;
+	for(int i = 0; i < n; ++i) {
+		vector<int> s;
+		scanf("%d", &tmpN);
+		for(int j = 0; j < tmpN; ++j) {
+			scanf("%d", &tmp);
+			s.push_back(tmp);
+		}
+		sort(s.begin(), s.end());
+		vector<int>::iterator iter = unique(s.begin(), s.end());
+		s.erase(iter, s.end());
+		v.push_back(s);
+	}
+	scanf("%d", &n);
+	int a, b;
+	double result;
+	for(int i = 0; i < n; ++i) {
+		scanf("%d%d", &a, &b);
+		int maxSize = v[a-1].size() + v[b-1].size();
+		vector<int> v1(maxSize, -1);
+		vector<int> v2(maxSize, -1);
+		vector<int>::iterator it1;
+		vector<int>::iterator it2;
+		it1 = set_union(v[a-1].begin(), v[a-1].end(), v[b-1].begin(), v[b-1].end(), v1.begin());
+		it2 = set_intersection(v[a-1].begin(), v[a-1].end(), v[b-1].begin(), v[b-1].end(), v2.begin());
+		result = 100.0 * (it2 - v2.begin()) / (it1 - v1.begin());
+		printf("%.1f%%\n", result);
+//		cout << (v2.end() - it2) << " " << (v1.end() - it1) << endl;
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1062.cpp b/1062.cpp
new file mode 100644
index 0000000..39409b8
--- /dev/null
+++ b/1062.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+class Man {
+public:
+	string _id;
+	int _virtue;
+	int _talent;
+};
+
+bool cmp(const Man &lhs, const Man &rhs) {
+	if(lhs._virtue + lhs._talent == rhs._virtue + rhs._talent) {
+		if(lhs._virtue != rhs._virtue)
+			return lhs._virtue > rhs._virtue;
+		else
+			return lhs._id < rhs._id;
+	}
+	else
+		return lhs._virtue + lhs._talent > rhs._virtue + rhs._talent;
+}
+
+int main(int argc, char *argv[]) {
+	int N, L, H;
+	cin >> N >> L >> H;
+	vector< vector<Man> > man( 4, vector<Man>() );
+	Man tmp;
+	for(int i = 0; i < N; ++i) {
+		cin >> tmp._id;
+		scanf("%d%d", &tmp._virtue, &tmp._talent);
+		if(tmp._virtue < L || tmp._talent < L)
+			continue;
+		if(tmp._virtue >= H && tmp._talent >= H) {
+			man[0].push_back(tmp);
+		}
+		else if(tmp._virtue >= H && tmp._talent < H) {
+			man[1].push_back(tmp);
+		}
+		else if(tmp._virtue < H && tmp._talent < H && tmp._virtue >= tmp._talent) {
+			man[2].push_back(tmp);
+		}
+		else {
+			man[3].push_back(tmp);
+		}
+	}
+
+	int actual = 0;
+	for(int i = 0; i < 4; ++i) {
+		actual += man[i].size();
+		sort(man[i].begin(), man[i].end(), cmp);
+	}
+	cout << actual << endl;
+	for(int i = 0; i < 4; ++i) {
+		for(int j = 0; j < man[i].size(); ++j){
+			cout << man[i][j]._id;
+			printf(" %d %d\n", man[i][j]._virtue, man[i][j]._talent);
+		}
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1065.cpp b/1065.cpp
new file mode 100644
index 0000000..0bcf32a
--- /dev/null
+++ b/1065.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <cstdio>
+
+using namespace std;
+
+typedef long long lint;
+
+bool CompareBigInt(lint a, lint b, lint c) {
+	lint sum = a + b;
+	if(a > 0 && b > 0 && sum <= 0)
+		return true;
+	if(a < 0 && b < 0 && sum >= 0)
+		return false;
+	return sum > c;
+}
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	cin >> n;
+	lint  a, b, c;
+	bool result;
+	for(int i = 0; i < n; ++i) {
+		cin >> a >> b >> c;
+		result = CompareBigInt(a, b, c);
+		cout << "Case #" << i + 1 << ": ";
+		if(result)
+			cout << "true" << endl;
+		else
+			cout << "false" << endl;
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/1066.cpp b/1066.cpp
new file mode 100644
index 0000000..f47d297
--- /dev/null
+++ b/1066.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+
+using namespace std;
+
+const int MAXTABLE = 10;
+
+int returnRoot( vector<int> &v) {
+	if(v.size() == 1)
+		return v[0];
+	if(v.size() <= 0)
+		return 0;
+
+	sort(v.begin(), v.end());
+
+	vector<int> f(MAXTABLE, 0);
+	int base = 2;
+	f[0] = 1;
+	for(int i = 1; i < f.size(); ++i, base *= 2)  
+		f[i] += f[i-1] + base;
+
+	// for(int i = 0; i < f.size(); ++i)
+	// 	printf("%d ", f[i]);
+	
+	int height = 0, n = v.size();
+	for(; height < f.size(); ++height) {
+		if(f[height] >= n)
+			break;
+	}
+	int remain = n - f[height-1];
+	int before = min( (f[height] - f[height-1]) / 2,  remain);
+	return v[ before + (f[height-1] - 1) / 2 ];
+}
+
+int main(int argc, char* argv[]) {
+	int N;
+	scanf("%d", &N);
+	vector<int> v(N, 0);
+	for(int i = 0; i < N; ++i) {
+		scanf("%d", &v[i]);
+	}
+	printf("%d\n", returnRoot(v));
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1073.cpp b/1073.cpp
new file mode 100644
index 0000000..626f29f
--- /dev/null
+++ b/1073.cpp
@@ -0,0 +1,73 @@
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+int string2Int(string s) {
+	stringstream ss;
+	ss << s;
+	int a;
+	ss >> a;
+	return a;
+}
+
+int main(int argc, char *argv[]) {
+	string oriStr;
+	cin >> oriStr;
+	bool digitSign = true;
+	if('-' == oriStr[0])
+		digitSign = false;
+	int digitStart = oriStr[1] - '0';
+	vector<int> after;
+	int index = 3;
+	while('E' != oriStr[index]) {
+		after.push_back(oriStr[index] - '0');
+		++index;
+	}
+	
+	++index;
+	int shiftSign = true;
+	if('-' == oriStr[index])
+		shiftSign= false;
+	int shift = 0;
+	++index;
+	shift = string2Int(oriStr.substr(index));
+	// cout << digitSign << " " << digitStart << " " << shiftSign << " " <<  shift << endl;
+	if(!digitSign)
+		printf("-");
+	int pos = 1;
+	// cout << shiftSign << " " << shift << endl;
+	if(!shiftSign && shift > 0) {
+		pos -= shift;
+		pos = -pos;
+		printf("0.");
+		for(int i = 0; i < pos; ++i){
+			printf("0");
+		}
+		printf("%d", digitStart);
+		for(int i = 0; i < after.size(); ++i)
+			printf("%d", after[i]);
+		printf("\n");
+	}
+	else {
+		printf("%d", digitStart);
+		pos--;
+		pos += shift;
+		for(int i = 0; i < after.size(); ++i) {
+			if(pos == i)
+				printf(".");
+			printf("%d", after[i]);
+		}
+		// cout << pos <<" " << after.size() << " " << pos - after.size() << endl;
+		for(int i = 0; i < pos - int(after.size()); ++i)
+			printf("0");
+		printf("\n");
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1076.cpp b/1076.cpp
new file mode 100644
index 0000000..0076076
--- /dev/null
+++ b/1076.cpp
@@ -0,0 +1,125 @@
+#include <iostream>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+#include <set>
+#include <queue>
+
+using namespace std;
+
+int all;
+
+// int forward(vector< vector<int> > &w, int L, int index) {
+// 	if(L <= 0 || index >= w.size())
+// 		return 0;
+// 	set<int> s;
+// 	s.insert(index);
+// 	vector<int> v1;
+// 	set<int> s2;
+// 	vector<int> v2;
+// 	v1.push_back(index);
+// 	for(int i = 0; i < L; ++i) {
+// 		for(int j = 0; j < v1.size(); ++j) {
+// 			int cur = v1[j];
+// 			for(int k = 0; k < w[cur].size(); ++k) {
+// 				// v2.push_back(w[cur][k]);
+// 				if(s.find(w[cur][k]) == s.end()) {
+// 					s2.insert( w[cur][k] );
+// 				}
+// 			}
+// 		}
+// 		v1.clear();
+// 		for(set<int>::iterator iter = s2.begin(); iter != s2.end(); ++iter) {
+// 			s.insert(*iter);
+// 			v1.push_back(*iter);
+// 		}
+// 		s2.clear();
+// 	}
+// 	return s.size() - 1;
+// }
+
+int forward(vector< vector<int> > &w, int L, int index, int N) {
+	if(L <= 0 || index >= w.size())
+		return 0;
+	int curL = 0;
+	queue<int> q;
+	q.push(index);
+	q.push(-1);
+	vector<int> visit(N+1, 0);
+	visit[index] = 1;
+	while(curL < L) {
+
+		// cout << "curL is :" << curL << endl;
+
+		// vector<int> tmpV;
+		// while(q.size() != 0) {
+		// 	cout << q.front() <<" ";
+		// 	tmpV.push_back(q.front());
+		// 	q.pop();
+		// }
+		// cout << endl;
+		// for(int i = 0; i < tmpV.size(); ++i)
+		// 	q.push(tmpV[i]);
+
+
+
+		if(q.front() == -1 && q.size() == 1)
+			break;
+		else if(q.front() == -1) {
+			++curL;
+			q.pop();
+			q.push(-1);
+			continue;
+		}
+		for(int i = 0; i < w[q.front()].size(); ++i) {
+			if(visit[ w[q.front()][i] ] == 0) {
+				visit[ w[q.front()][i] ] = 1;
+				q.push( w[q.front()][i] );
+			}
+		}
+		q.pop();
+	}
+	int result = 0;
+	for(int i = 0; i < visit.size(); ++i){
+		if(1 == visit[i]) {
+			++result;
+			// cout << i <<" ";
+		}
+	}
+	// cout << endl;
+	return result - 1;
+
+}
+
+
+
+int main(int argc, char *argv[]) {
+	int N, L;
+	scanf("%d%d", &N, &L);
+	vector< vector<int> > w( N+1, vector<int>() );
+	vector<int> f(N+1, 0);
+	int tmp;
+	for(int i = 1; i <= N; ++i) {
+		scanf("%d", &tmp);
+		int index;
+		
+		for(int j = 0; j < tmp; ++j) {
+			scanf("%d", &index);
+			w[index].push_back(i);
+		}
+	}
+	// all = 0;
+	// for(int i = 0; i < f.size(); ++i)
+	// 	all += f[i];
+	
+	// printf("all point %d", all);
+
+	scanf("%d", &tmp);
+	for(int i = 0; i < tmp; ++i) {
+		int index;
+		scanf("%d", &index);
+		printf("%d\n", forward(w, L, index, N));
+	}
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1078.cpp b/1078.cpp
new file mode 100644
index 0000000..78f6c7a
--- /dev/null
+++ b/1078.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <vector>
+#include <cmath>
+
+const int MAXNUM = 11000;
+
+using namespace std;
+
+int main(int argc, char *argv) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+
+	vector<bool> isPrime(MAXNUM, true);
+	isPrime[0] = false;
+	isPrime[1] = false;
+	for(int i = 2; i < int( sqrt( double(MAXNUM) ) ); ++i) {
+		if(!isPrime[i])
+			continue;
+		for(int j = i + i; j < MAXNUM; j += i) {
+			isPrime[j] = false;
+		}
+	}
+	
+	int MSize, N;
+	cin >> MSize >> N;
+	// resize M
+	for(int i = MSize; i < isPrime.size(); ++i) {
+		if(isPrime[i]) {
+			MSize = i;
+			break;
+		}
+	}
+	
+	vector<bool> Ok(MSize, true);
+	vector<bool> h(MSize, false);
+	for(int i = 0; i < N; ++i) {
+		int num, d;
+		scanf("%d", &num);
+		d = num % MSize;
+		if(!Ok[d]) {
+			printf("-");
+		}
+		else {
+			bool findPos = false;
+			int nowD;
+			for(int j = 0; j < MSize; ++j) {
+				nowD = (d + j * j) % MSize;
+				if(!h[nowD]) {
+					h[nowD] = true;
+					findPos = true;
+					break;
+				}
+			}
+			if(findPos) {
+				printf("%d", nowD);
+			}
+			else {
+				Ok[d] = false;
+				printf("-");
+			}
+		}
+
+		if(N-1 == i) 
+			printf("\n");
+		else
+			printf(" ");
+
+	}
+	 
+	return 0;
+}
\ No newline at end of file
diff --git a/1083.cpp b/1083.cpp
new file mode 100644
index 0000000..303e47d
--- /dev/null
+++ b/1083.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+class Student {
+public:
+	string _name;
+	string _ID;
+	int _grade;
+
+	bool operator< (const Student &rhs) const{
+		return _grade > rhs._grade;
+	}
+};
+
+// bool cmp(const Student &lhs, const Student &rhs) {
+// 	return lhs._grade > rhs._grade;
+// }
+
+int main(int argc, char *argv[]) {
+	int N;
+	cin >> N;
+	vector<Student> students(N);
+	for(int i = 0; i < N; ++i) {
+		cin >> students[i]._name >> students[i]._ID >> students[i]._grade;
+	}
+	int lowBound, highBound;
+	cin >> lowBound >> highBound;
+	sort(students.begin(), students.end());
+	if(students.size() == 0 || students[0]._grade < lowBound || students[students.size()-1]._grade > highBound){
+		printf("NONE\n");
+	}
+	else {
+		for(int i = 0; i < N; ++i)
+			if(students[i]._grade >= lowBound && students[i]._grade <= highBound)
+				cout << students[i]._name << " " << students[i]._ID << endl;
+	}
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1084.cpp b/1084.cpp
new file mode 100644
index 0000000..ce23479
--- /dev/null
+++ b/1084.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <set>
+
+using namespace std;
+
+int main(int argc, char* argv[]) {
+
+	string ori, act;
+	cin >> ori >> act;
+	int j = 0;
+	set<char> result;
+	for(int i = 0; i < ori.size(); ++i) {
+		if(j >= act.size() || ori[i] != act[j]) {
+			if(ori[i] >= 'a' && ori[i] <= 'z')
+				ori[i] = ori[i] - 'a' + 'A';
+			if( result.end() == result.find(ori[i]) ) {
+				cout << ori[i];
+				result.insert(ori[i]);
+			}
+		}
+		else {
+			++j;
+		}
+	}
+	cout << endl;
+	return 0;
+}
\ No newline at end of file
diff --git a/1085.cpp b/1085.cpp
new file mode 100644
index 0000000..7a9acf0
--- /dev/null
+++ b/1085.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+vector<int> v;
+int N, p;
+
+int main(int argc, char *argv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+	scanf("%d%d", &N, &p);
+	for(int i = 0; i < N; ++i) {
+		int tmp;
+		scanf("%d", &tmp);
+		if(tmp >= 1)
+			v.push_back(tmp);
+	}
+
+	sort(v.begin(), v.end());
+	
+	int result = -1;
+	int M;
+	for(int i = 0; i < v.size(); ++i) {
+		M = v[i] * p;
+		int cur;
+		if(M < 0)
+			cur = v.size() - i; 
+		else
+			cur = upper_bound(v.begin(), v.end(), M) - v.begin() - i;
+		result = max(result, cur);
+	}
+
+	printf("%d\n", result);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1086.cpp b/1086.cpp
new file mode 100644
index 0000000..8347f3c
--- /dev/null
+++ b/1086.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <stack>
+
+using namespace std;
+
+class Node{
+public:
+	int val;
+	Node *left;
+	Node *right;
+
+	Node(int a):val(a), left(NULL), right(NULL) {};
+
+};
+
+class Action{
+public:
+	bool in;
+	int val;
+};
+
+Node* returnRoot(vector<Action> &v, int up, int down) {
+	if(down - up == 1) {
+		Node *root = new Node(v[up].val);
+		return root;
+	}
+	if(down - up < 1) {
+		return NULL;
+	}
+	int i = up;
+	// stack<int> s;
+	int num = 0;
+	for(; i <= down; ++i) {
+		if(v[i].in) {
+			++num;
+		}
+		else {
+			--num;
+		}
+		if(0 == num)
+			break;
+	}
+	Node *root = new Node(v[up].val);
+	root->left = returnRoot(v, up+1, i-1);
+	root->right = returnRoot(v, i+1, down);
+	return root;
+}
+
+void printTree(Node *root, vector<int> &v) {
+	if(NULL == root)
+		return;
+	printTree(root->left, v);
+	printTree(root->right, v);
+	v.push_back(root->val);
+}
+
+int main(int argc, char *argv[]) {
+	int N;
+	cin >> N;
+	string tmp;
+	vector<Action> v;
+	
+	int i = 0;
+
+	while(cin >> tmp) {
+		Action act;
+		if(tmp == "Push") {
+			act.in = true;
+			cin >> act.val;
+		}
+		else {
+			act.in = false;
+		}
+		v.push_back(act);
+	}
+	if(0 == N)
+		return 0;
+	int up = 0, down = v.size()-1;
+	Node *root = returnRoot(v, up, down);
+	vector<int> result;
+	printTree(root, result);
+	if(result.size() != 0)
+		printf("%d", result[0]);
+	for(int i = 1; i < result.size(); ++i)
+		printf(" %d", result[i]);
+	printf("\n");
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1088.cpp b/1088.cpp
new file mode 100644
index 0000000..409e4bc
--- /dev/null
+++ b/1088.cpp
@@ -0,0 +1,136 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+
+//#define DEBUG
+
+using namespace std;
+
+typedef long long lint;
+
+lint gcd(lint a, lint b) {
+	a = abs(a);
+	b = abs(b);
+	lint result = 1;
+	if(a == 0 || b == 0)
+		return 1;
+	lint tmp;
+	while(b != 0) {
+		tmp = b;
+		b = a % b;
+		a = tmp;
+	}
+	return a;
+}
+
+void reduce(lint &a, lint &b) {
+	lint cut = gcd(a, b);
+	a /= cut;
+	b /= cut;
+}
+
+void printR(lint a, lint b) {
+	reduce(a, b);
+	
+	bool isNeg = false;
+	if(a < 0) {
+		isNeg = true;
+		printf("(-");
+		a = -a;
+	}
+
+	if(0 == a || 1 == b) {
+		printf("%lld", a);
+	}
+	else {
+		lint iPart = a / b;
+		if(0 != iPart) { 
+			printf("%lld %lld/%lld", iPart, a % b, b);
+		}
+		else {
+			printf("%lld/%lld", a, b);
+		}
+	}
+	if(isNeg) 
+		printf(")");
+}
+
+void rSum(lint a, lint b, lint c, lint d) {
+	lint f = b * d / gcd(b, d);
+	lint e = f / b * a + f / d * c;
+	reduce(e, f);
+	printR(a, b);
+	cout << " + ";
+	printR(c, d);
+	cout << " = ";
+	printR(e, f);
+	printf("\n");
+}
+
+void rDifference(lint a, lint b, lint c, lint d) {
+	lint f = b * d / gcd(b, d);
+	lint e = f / b * a - f / d * c;
+	reduce(e, f);
+	printR(a, b);
+	cout << " - ";
+	printR(c, d);
+	cout << " = ";
+	printR(e, f);
+	printf("\n");
+}
+
+void rProduct (lint a, lint b, lint c, lint d) {
+	lint f = b * d;
+	lint e = a * c;
+	reduce(e, f);
+	printR(a, b);
+	cout << " * ";
+	printR(c, d);
+	cout << " = ";
+	printR(e, f);
+	printf("\n");
+}
+
+
+void rQuotient (lint a, lint b, lint c, lint d) {
+	lint f = b * c;
+	lint e = a * d;
+
+	if(e < 0 && f < 0 || e > 0 && f < 0) {
+		e = -e;
+		f = -f;
+	}
+
+	reduce(e, f);
+	printR(a, b);
+	cout << " / ";
+	printR(c, d);
+	cout << " = ";
+	if(0 != f)
+		printR(e, f);
+	else
+		printf("Inf");
+	printf("\n");
+}
+
+int main(int argc, char *argv[]) {
+#ifdef DEBUG
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#else
+#endif
+	// 2/3 -4/2
+	lint a, b, c, d;
+	scanf("%lld/%lld %lld/%lld", &a, &b, &c, &d);
+	
+	reduce(a, b);
+	reduce(c, d);
+	
+	rSum(a, b, c, d);
+	rDifference(a, b, c, d);
+	rProduct(a, b, c, d);
+	rQuotient(a, b, c, d);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1089.cpp b/1089.cpp
new file mode 100644
index 0000000..f557286
--- /dev/null
+++ b/1089.cpp
@@ -0,0 +1,71 @@
+#include <iostream>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+
+using namespace std;
+
+void printV(const vector<int> v) {
+	printf("%d", v[0]);
+	for(int i = 1; i < v.size(); ++i) 
+		printf(" %d", v[i]);
+	printf("\n");
+}
+
+bool MergeSort(vector<int> &oriV, vector<int> &curV) {
+	
+
+
+}
+
+bool insertionSort(const vector<int> &oriV, const vector<int> &curV) {
+	vector<int> v(oriV);
+
+	if(oriV.size() == 1) {
+		printf("Insertion Sort\n");
+		printV(v);
+		return true;
+	}
+
+	bool result = false;
+
+	for(int i = 1; i < oriV.size(); ++i) {
+		// move one step;
+		int j = i - 1;
+		for(; j >= 0; --j) {
+			if(v[i] > v[j])
+				break;
+		}
+		int tmpI = v[i];
+		++j;
+		for(int k = i; k >= j + 1; --k) {
+			v[k] = v[k-1];
+		}
+		v[j] = tmpI;
+
+		// check equal
+		if(result) {
+			printf("Insertion Sort\n");
+			printV(v);
+			break;
+		}
+		if(curV == v) {
+			result = true;
+		}
+	}
+	return result;
+}
+
+int main(int argc, char *argv[]) {
+	int N;
+	scanf("%d", &N);
+	vector<int> oriV(N, 0);
+	vector<int> curV(N, 0);
+	for(int i = 0; i < N; ++i) 
+		scanf("%d", &oriV[i]);
+	for(int i = 0; i < N; ++i)
+		scanf("%d", &curV[i]);
+	if( !insertionSort(oriV, curV) )
+		MergeSort(oriV, curV);
+	return 0;
+}
\ No newline at end of file
diff --git a/1091.cpp b/1091.cpp
new file mode 100644
index 0000000..ff55b90
--- /dev/null
+++ b/1091.cpp
@@ -0,0 +1,114 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <stack>
+
+//#define DEBUG
+
+using namespace std;
+
+bool MRI[1300][130][70];
+int M, N, L, T;
+int volume;
+
+class Point {
+public:
+	int x;
+	int y;
+	int z;
+	Point(int i, int j, int k): x(i), y(j), z(k){};
+};
+
+stack<Point> s;
+
+
+void dfs(int x, int y, int z) {
+	if(!MRI[x][y][z])
+		return;
+	s.push(Point(x, y, z));
+	while(!s.empty()) {
+		x = s.top().x;
+		y = s.top().y;
+		z = s.top().z;
+		s.pop();
+		if(!MRI[x][y][z])
+			continue;
+		MRI[x][y][z] = false;
+		++volume;
+		if(x > 0)
+			s.push(Point(x - 1, y, z));
+		if(y > 0)
+			s.push(Point(x, y - 1, z));
+		if(z > 0)
+			s.push(Point(x, y, z - 1));
+		if(x < M - 1)
+			s.push(Point(x + 1, y, z));
+		if(y < N - 1)
+			s.push(Point(x, y + 1, z));
+		if(z < L - 1)
+			s.push(Point(x, y, z + 1));
+	}
+}
+
+//void dfs(int x, int y, int z) {
+//	if(!MRI[x][y][z])
+//		return;
+//
+//	MRI[x][y][z] = false;
+//	++volume;
+//
+//	if(x > 0)
+//		dfs(x - 1, y, z);
+//	if(y > 0)
+//		dfs(x, y - 1, z);
+//	if(z > 0)
+//		dfs(x, y, z - 1);
+//	if(x < M - 1)
+//		dfs(x + 1, y, z);
+//	if(y < N - 1)
+//		dfs(x, y + 1, z);
+//	if(z < L - 1)
+//		dfs(x, y, z + 1);
+//
+//}
+
+
+
+int main(int argc, char *argv[]) {
+#ifdef DEBUG
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#else
+#endif
+	
+	scanf("%d%d%d%d", &M, &N, &L, &T);
+	for(int k = 0; k < L; ++k) {
+		for(int i = 0; i < M; ++i) {
+			for(int j = 0; j < N; ++j) {
+				int tmp;
+				scanf("%d", &tmp);
+				if(1 == tmp)
+					MRI[i][j][k] = true;
+				else
+					MRI[i][j][k] = false;
+			}
+		}
+	}
+	
+	int result = 0;
+
+	for(int k = 0; k < L; ++k) {
+		for(int i = 0; i < M; ++i) {
+			for(int j = 0; j < N; ++j) {
+				volume = 0;
+				dfs(i, j, k);
+				if(volume >= T)
+					result += volume;
+			}
+		}
+	}
+
+	printf("%d\n", result);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/1095.cpp b/1095.cpp
new file mode 100644
index 0000000..cd6df2e
--- /dev/null
+++ b/1095.cpp
@@ -0,0 +1,122 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include<cstring>
+#include<string>
+#include<map>
+#include<algorithm>
+#include<vector>
+
+using namespace std;
+
+int n, k, carNum=-1;
+
+struct record{
+	string id;
+	int time;
+	bool state;
+}rec[10009];
+
+struct car{
+	string name;
+	vector<int>start;
+	vector<int>end;
+	int total;
+	car(){
+		total=0;
+	}
+}cars[20010];
+
+bool cmp(record a, record b){
+	if(a.id!=b.id) return a.id<b.id;
+	else{
+		return a.time<b.time;
+	}
+}
+
+vector<record> format;
+
+int main(int argc, char *argv[]) {
+#ifndef ONLINE_JUDGE
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+	scanf("%d%d", &n, &k);
+	int h,m,s;
+	char state[10];
+	for(int i=0; i<n; i++){
+		cin>>rec[i].id;
+		scanf("%d:%d:%d %s", &h, &m, &s, state);
+		rec[i].time=h*3600+m*60+s;
+		if(state[0]=='i') { 
+			rec[i].state=true;
+		}
+		else 
+			rec[i].state=false;
+	}
+
+	sort(rec, rec+n, cmp);
+
+	for(int i=0; i<n-1; i++ ){
+		if(rec[i].id!=rec[i+1].id){
+			i++;
+		}
+		if(rec[i].state==true && rec[i+1].state==false){
+			format.push_back(rec[i]);
+			format.push_back(rec[i+1]);
+		}else if(rec[i].state==true && rec[i+1].state==true) i++;
+		else if(rec[i].state==false && rec[i+1].state==false)i+=2;
+		else i++;
+	}
+
+	string lastname="aa";
+
+	for(int i=0; i<format.size()-1; i+=2){
+		if(format[i].id!=lastname){
+			carNum++;
+			lastname=format[i].id;
+			cars[carNum].name=format[i].id;
+			cars[carNum].start.push_back(format[i].time);
+			cars[carNum].end.push_back(format[i+1].time);
+			cars[carNum].total+=(format[i+1].time-format[i].time);
+		}
+		else{
+			cars[carNum].start.push_back(format[i].time);
+			cars[carNum].end.push_back(format[i+1].time);
+			cars[carNum].total+=(format[i+1].time-format[i].time);
+		}
+	}
+
+	int point, sum=0;
+	for(int i=0; i<k; i++){
+		sum=0;
+		scanf("%d:%d:%d", &h, &m, &s);
+		point=3600*h+60*m+s;
+		for(int i=0; i<=carNum; i++){
+			for(int j=0; j<cars[i].start.size(); j++){
+				if(point>=cars[i].start[j] && point<=cars[i].end[j]){
+					sum++;
+				}
+			}
+		}
+		printf("%d\n", sum);
+	}
+
+	int maxtime=-1;
+	for(int i=0; i<=carNum; i++){
+		if(cars[i].total>maxtime){
+			maxtime=cars[i].total;
+		}
+	}
+
+	for(int i=0; i<=carNum; i++){
+		if(cars[i].total==maxtime){
+			cout<<cars[i].name<<" ";
+		}
+	}
+	printf("%02d:%02d:%02d", maxtime/3600, maxtime%3600/60, maxtime%60);
+
+	//system("pause");
+	return 0;
+}
+