├── README.md
└── 代码
    ├── 1.cpp
    ├── 10.cpp
    ├── 11.cpp
    ├── 12-1.cpp
    ├── 12.cpp
    ├── 13.cpp
    ├── 14.cpp
    ├── 15.cpp
    ├── 16.cpp
    ├── 17.cpp
    ├── 18.cpp
    ├── 19.cpp
    ├── 2.cpp
    ├── 20-1.cpp
    ├── 20.cpp
    ├── 21.cpp
    ├── 22.cpp
    ├── 23.cpp
    ├── 24.cpp
    ├── 25.cpp
    ├── 26.cpp
    ├── 27.cpp
    ├── 28.cpp
    ├── 29.cpp
    ├── 3.cpp
    ├── 30.cpp
    ├── 31.cpp
    ├── 32.cpp
    ├── 33.cpp
    ├── 34-1.cpp
    ├── 34.cpp
    ├── 35-1.cpp
    ├── 35.cpp
    ├── 36.cpp
    ├── 37-1.cpp
    ├── 37.cpp
    ├── 38.cpp
    ├── 39.cpp
    ├── 4.cpp
    ├── 40.cpp
    ├── 41.cpp
    ├── 42.cpp
    ├── 43.cpp
    ├── 44.cpp
    ├── 45-1.cpp
    ├── 45.cpp
    ├── 46.cpp
    ├── 47.cpp
    ├── 48.cpp
    ├── 49.cpp
    ├── 5-1.cpp
    ├── 5-2.cpp
    ├── 5-3.cpp
    ├── 50.cpp
    ├── 51.cpp
    ├── 52.cpp
    ├── 53-1.cpp
    ├── 53.cpp
    ├── 54.cpp
    ├── 55.cpp
    ├── 56.cpp
    ├── 57.cpp
    ├── 58.cpp
    ├── 6.cpp
    ├── 7.cpp
    ├── 8.cpp
    ├── 9.cpp
    ├── 代码列表.txt
    ├── 王道考研机试指南.pdf
    └── 笔记 .md


/README.md:
--------------------------------------------------------------------------------
1 | # 代码合集
2 | 王道考研机试指南的代码合集，附有一些笔记和感悟
3 | 
4 | 文件夹中包括机试指南的pdf，笔记部分，和代码对应题目的列表
5 | 
6 | 如发现任何问题欢迎在下面留言
7 | 
8 | 之前的版本有些粗糙，重写版见博客：[王道考研机试指南重写](https://blog.csdn.net/freedom1523646952/article/details/123883396?spm=1001.2014.3001.5502)
9 | 


--------------------------------------------------------------------------------
/代码/1.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/1.cpp


--------------------------------------------------------------------------------
/代码/10.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | struct goods {
 6 | 	double rate;
 7 | 	double j;
 8 | 	double f;
 9 | };
10 | bool cmp(goods g1, goods g2) {
11 | 	return g1.rate > g2.rate;
12 | }
13 | 
14 | void func() {
15 | 	int n;
16 | 	double m;
17 | 	while ((cin >> m >> n) && (n != -1 && m != -1)) {
18 | 		vector<goods> a(n);
19 | 		for (int i = 0;i < n;i++) {
20 | 			cin >> a[i].j >> a[i].f;
21 | 			a[i].rate = a[i].j / a[i].f;
22 | 		}
23 | 		sort(a.begin(), a.end(), cmp);
24 | 		double ans = 0;
25 | 		double sum = 0;
26 | 		for (int i = 0;i < n;i++) {
27 | 			if (sum + a[i].f <= m) {
28 | 				sum += a[i].f;
29 | 				ans += a[i].j;
30 | 			}
31 | 			else {
32 | 				ans += (m - sum) * a[i].rate;
33 | 				break;
34 | 			}
35 | 		}
36 | 		printf("%.3lf\n", ans);
37 | 	}
38 | }
39 | int main() {
40 | 	func();
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/代码/11.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<algorithm>
 4 | 
 5 | using namespace std;
 6 | struct show {
 7 | 	int start;
 8 | 	int end;
 9 | 	bool operator <(const show& s) {
10 | 		return end < s.end;
11 | 	}
12 | };
13 | vector<show> a(100);
14 | int main() {
15 | 	int n;
16 | 	while (cin >> n && n != 0) {
17 | 		for (int i = 0;i < n;i++) {
18 | 			cin >> a[i].start >> a[i].end;
19 | 		}
20 | 		sort(a.begin(), a.begin() + n);
21 | 		int now = 0;
22 | 		int ans = 0;
23 | 		for (int i = 0;i < n;i++) {
24 | 			if (a[i].start >= now) {
25 | 				now = a[i].end;
26 | 				ans++;
27 | 			}
28 | 		}
29 | 		cout << ans << endl;
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/代码/12-1.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stack>
 3 | using namespace std; 
 4 | stack<int> S; 
 5 | char str[110]; 
 6 | char ans[110]; 
 7 | int main () { 
 8 | 	while (scanf ("%s",str) != EOF) { 
 9 | 		int i; 
10 | 		for (i = 0;str[i] != 0;i ++) { 
11 | 			if (str[i] == '(') { 
12 | 				S.push(i); 
13 | 				ans[i] = ' ';
14 | 			} 
15 | 			else if (str[i] == ')') { 
16 | 				if (S.empty() == false) { 
17 | 					S.pop(); 
18 | 					ans[i] = ' '; 
19 | 				} 
20 | 				else ans[i] = '?'; 
21 | 			} 
22 | 			else ans[i] = ' ';
23 | 		} 
24 | 		while(!S.empty()) { 
25 | 			ans[ S.top() ] = '$'; 
26 | 			S.pop(); 
27 | 		} 
28 | 		ans[i] = 0;
29 | 		puts(str); 
30 | 		puts(ans); 
31 | 	} 
32 | 	return 0; 
33 | }
34 | 


--------------------------------------------------------------------------------
/代码/12.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | 
 4 | using namespace std;
 5 | 
 6 | bool find(string& s, int index) {
 7 | 	while (index > 0) {
 8 | 		index--;
 9 | 		if (s[index] == '(') {
10 | 			s[index] = 'a';
11 | 			return true;
12 | 		}
13 | 	}
14 | 	return false;
15 | }
16 | int main() {
17 | 	string data;
18 | 	while (cin >> data) {
19 | 		cout << data << endl;
20 | 		for (int i = 0;i < data.length();i++) {
21 | 			if (data[i] == ')') {
22 | 				if (find(data, i)) {
23 | 					data[i] = 'a';
24 | 				}
25 | 			}
26 | 		}
27 | 		for (int i = 0;i < data.length();i++) {
28 | 			if (data[i] == '(') {
29 | 				cout << "$";
30 | 			}
31 | 			else if (data[i] == ')') {
32 | 				cout << "?";
33 | 			}
34 | 			else {
35 | 				cout << " ";
36 | 			}
37 | 		}
38 | 		cout << endl;
39 | 	}
40 | 	return 0;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/代码/13.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stack>
 3 | #include<string>
 4 | using namespace std;
 5 | int getPro(char function) {
 6 | 	if (function == '*' || function == '/') {
 7 | 		return 3;
 8 | 	}
 9 | 	else if (function == '+' || function == '-') {
10 | 		return 2;
11 | 	}
12 | 	else if(function == 'a'){
13 | 		return 1;
14 | 	}
15 | 	else {
16 | 		return 0;
17 | 	}
18 | }
19 | double count(double a, double b, char func) {
20 | 	switch (func) {
21 | 	case '*':
22 | 		return a * b;
23 | 	case '/':
24 | 		return a / b;
25 | 	case '+':
26 | 		return a + b;
27 | 	case '-':
28 | 		return a - b;
29 | 	}
30 | 	return 0;
31 | }
32 | bool process_stack(stack<double>& numbers, stack<char>& functions, char func) {
33 | 	int top_pro;
34 | 	int func_pro;
35 | 	char top;
36 | 	top = functions.top();
37 | 	top_pro = getPro(top);
38 | 	func_pro = getPro(func);
39 | 	if (top_pro >= func_pro) {
40 | 		functions.pop();
41 | 		double a, b;
42 | 		b = numbers.top();
43 | 		numbers.pop();
44 | 		a = numbers.top();
45 | 		numbers.pop();
46 | 		double ans = count(a, b, top);
47 | 		numbers.push(ans);
48 | 		return true;
49 | 	}
50 | 	functions.push(func);
51 | 	return false;
52 | }
53 | typedef pair<int, int> mytype;
54 | mytype GetNumber(string s, int index) {
55 | 	int ans = 0;
56 | 	while (index < s.length() && s[index] >= '0' && s[index] <= '9') {
57 | 		ans = ans * 10 + s[index] - '0';
58 | 		index++;
59 | 	}
60 | 	mytype value(ans, index);
61 | 	return value;
62 | }
63 | int main() {
64 | 	string s;
65 | 	stack<double> nums;
66 | 	stack<char> operators;
67 | 	while (getline(cin,s)) {
68 | 		if (s[0] == '0' && s.length() == 1) {
69 | 			break;
70 | 		}
71 | 		while (!operators.empty()) operators.pop();
72 | 		operators.push('z');
73 | 		char oper;
74 | 		double num;
75 | 		int index = 0;
76 | 		while (true) {
77 | 			mytype value = GetNumber(s, index);
78 | 			nums.push(value.first);
79 | 			if (value.second == s.length()) {
80 | 				while (process_stack(nums, operators, 'a')) {}
81 | 				double ans = nums.top();
82 | 				nums.pop();
83 | 				printf("%.2f\n", ans);
84 | 				break;
85 | 			}
86 | 			oper = s[value.second+1];
87 | 			index = value.second + 3;
88 | 			while (process_stack(nums, operators, oper)) {}
89 | 		}
90 | 	}
91 | }
92 | 


--------------------------------------------------------------------------------
/代码/14.cpp:
--------------------------------------------------------------------------------
  1 | #include<stack>
  2 | #include<iostream>
  3 | 
  4 | using namespace std;
  5 | 
  6 | typedef pair<int, int> mytype;
  7 | int getPro(char function) {
  8 | 	if (function == '*' || function == '/') {
  9 | 		return 3;
 10 | 	}
 11 | 	else if (function == '+' || function == '-') {
 12 | 		return 2;
 13 | 	}
 14 | 	else if (function == 'a') {
 15 | 		return 1;
 16 | 	}
 17 | 	else {
 18 | 		return 0;
 19 | 	}
 20 | }
 21 | double count(double a, double b, char func) {
 22 | 	switch (func) {
 23 | 	case '*':
 24 | 		return a * b;
 25 | 	case '/':
 26 | 		return a / b;
 27 | 	case '+':
 28 | 		return a + b;
 29 | 	case '-':
 30 | 		return a - b;
 31 | 	}
 32 | 	return 0;
 33 | }
 34 | bool process_stack(stack<double>& numbers, stack<char>& functions, char func) {
 35 | 	int top_pro;
 36 | 	int func_pro;
 37 | 	char top;
 38 | 	top = functions.top();
 39 | 	top_pro = getPro(top);
 40 | 	func_pro = getPro(func);
 41 | 	if (top_pro >= func_pro) {
 42 | 		functions.pop();
 43 | 		double a, b;
 44 | 		b = numbers.top();
 45 | 		numbers.pop();
 46 | 		a = numbers.top();
 47 | 		numbers.pop();
 48 | 		double ans = count(a, b, top);
 49 | 		numbers.push(ans);
 50 | 		return true;
 51 | 	}
 52 | 	functions.push(func);
 53 | 	return false;
 54 | }
 55 | mytype GetNumber(string s, int index, int right) {
 56 | 	int ans = 0;
 57 | 	while (index < right && s[index] >= '0' && s[index] <= '9') {
 58 | 		ans = ans * 10 + s[index] - '0';
 59 | 		index++;
 60 | 	}
 61 | 	mytype value(ans, index);
 62 | 	return value;
 63 | }
 64 | double process(string s, int left, int right) {
 65 | 	stack<double> nums;
 66 | 	stack<char> operators;
 67 | 	operators.push('z');
 68 | 	char oper;
 69 | 	double num;
 70 | 	int index = left;
 71 | 	while (true) {
 72 | 		nums.push(value.first);
 73 | 		if (value.second == s.length()) {
 74 | 			while (process_stack(nums, operators, 'a')) {}
 75 | 			double ans = nums.top();
 76 | 			nums.pop();
 77 | 			return ans;
 78 | 		}
 79 | 		oper = s[value.second + 1];
 80 | 		index = value.second + 3;
 81 | 		while (process_stack(nums, operators, oper)) {}
 82 | 		
 83 | 	}
 84 | }
 85 | 
 86 | 
 87 | int main() {
 88 | 	stack<int> brackets;
 89 | 	string s;
 90 | 	cin >> s;
 91 | 	for (int i = 0;i < s.length();i++) {
 92 | 		if (s[i] == '(') {
 93 | 			brackets.push(i);
 94 | 		}
 95 | 		else if (s[i] == ')') {
 96 | 			int left = brackets.top() + 1;
 97 | 			brackets.pop();
 98 | 			int right = i - 1;
 99 | 			double ans = process(s, left, right);
100 | 		}
101 | 	}
102 | }


--------------------------------------------------------------------------------
/代码/15.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/15.cpp


--------------------------------------------------------------------------------
/代码/16.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<queue>
 3 | #include<vector>
 4 | 
 5 | using namespace std;
 6 | 
 7 | void func() {
 8 | 	int n;
 9 | 	priority_queue<int, vector<int>, greater<int>> Q;
10 | 	while (cin >> n && n != 0) {
11 | 		int NodeSum = 0;
12 | 		int AllSum = 0;
13 | 		int tmp;
14 | 		for (int i = 0;i < n;i++) {
15 | 			cin >> tmp;
16 | 			NodeSum += tmp;
17 | 			Q.push(tmp);
18 | 		}
19 | 		int first, second;
20 | 		while (Q.size() > 1) {
21 | 			first = Q.top();
22 | 			Q.pop();
23 | 			second = Q.top();
24 | 			Q.pop();
25 | 			AllSum += first + second;
26 | 			Q.push(first + second);
27 | 		}
28 | 		AllSum += Q.top();
29 | 		Q.pop();
30 | 		cout << AllSum - NodeSum << endl;
31 | 	}
32 | }
33 | 
34 | int main() {
35 | 	func();
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/代码/17.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/17.cpp


--------------------------------------------------------------------------------
/代码/18.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | struct Node
 5 | {
 6 | 	int val;
 7 | 	Node* rchild;
 8 | 	Node* lchild;
 9 | 	Node(){
10 | 		rchild = NULL;
11 | 		lchild = NULL;
12 | 	}
13 | };
14 | Node* addNode(Node* p,int val){
15 | 	if(p==NULL){
16 | 		p = new Node();
17 | 		p->val = val;
18 | 		return p;
19 | 	}
20 | 	if(p->val>val){
21 | 		p->lchild = addNode(p->lchild,val);
22 | 	}
23 | 	else{
24 | 		p->rchild = addNode(p->rchild,val);
25 | 	}
26 | 	return p;
27 | }
28 | void previsit(Node* root){
29 | 	cout<<root->val<<" ";
30 | 
31 | 	if(root->lchild){
32 | 		previsit(root->lchild);
33 | 	}
34 | 
35 | 	if(root->rchild){
36 | 		previsit(root->rchild);
37 | 	}
38 | }
39 | void midvisit(Node* root){
40 | 	if(root->lchild){
41 | 		midvisit(root->lchild);
42 | 	}
43 | 
44 | 	cout<<root->val<<" ";
45 | 
46 | 	if(root->rchild){
47 | 		midvisit(root->rchild);
48 | 	}
49 | }
50 | void behvisit(Node* root){
51 | 	if(root->lchild){
52 | 		behvisit(root->lchild);
53 | 	}
54 | 
55 | 	if(root->rchild){
56 | 		behvisit(root->rchild);
57 | 	}
58 | 
59 | 	cout<<root->val<<" ";
60 | }
61 | void func(){
62 | 	int n;
63 | 	int value;
64 | 	while(cin>>n){
65 | 		Node* root = NULL;
66 | 		for(int i=0;i<n;i++){
67 | 			cin>>value;
68 | 			root = addNode(root,value);
69 | 		}
70 | 		previsit(root);
71 | 		cout<<endl;
72 | 		midvisit(root);
73 | 		cout<<endl;
74 | 		behvisit(root);
75 | 		cout<<endl;
76 | 	}
77 | }
78 | int main(){
79 | 	func();
80 | 	return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/代码/19.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<string>
 4 | #include<algorithm>
 5 | using namespace std;
 6 | struct Node {
 7 | 	int val;
 8 | 	Node* lchild;
 9 | 	Node* rchild;
10 | };
11 | bool compare(vector<int> t1, vector<int> t2) {
12 | 	if (t1.size() != t2.size()) return false;
13 | 	for (int i = 0;i < t1.size();i++) {
14 | 		if (t1[i] != t2[i]) {
15 | 			return false;
16 | 		}
17 | 	}
18 | 	return true;
19 | }
20 | Node* create(Node* root, int val) {
21 | 	if (root == NULL) {
22 | 		root = new Node();
23 | 		root->val = val;
24 | 	}
25 | 	else if (root->val >= val) {
26 | 		root->lchild = create(root->lchild, val);
27 | 	}
28 | 	else {
29 | 		root->rchild = create(root->rchild, val);
30 | 	}
31 | 	return root;
32 | }
33 | void previsit(Node* root,vector<int>& ans) {
34 | 	ans.push_back(root->val);
35 | 	if (root->lchild) {
36 | 		previsit(root->lchild, ans);
37 | 	}
38 | 	if (root->rchild) {
39 | 		previsit(root->rchild, ans);
40 | 	}
41 | }
42 | void convert(string s, vector<int>& mid) {
43 | 	int len = s.length();
44 | 	for (int i = 0;i < len;i++) {
45 | 		int val = s[i] - '0';
46 | 		mid.push_back(val);
47 | 	}
48 | }
49 | void print_all(vector<int> res){
50 | 	for(int i=0;i<res.size();i++){
51 | 		cout<<res[i]<<" ";
52 | 	}
53 | 	cout<<endl;
54 | }
55 | void func() {
56 | 	int n;
57 | 	while (cin >> n&&n>0) {
58 | 		vector<int> pre;
59 | 		vector<int> mid;
60 | 		Node* root = NULL;
61 | 		string tmp;
62 | 		cin >> tmp;
63 | 		convert(tmp, mid);
64 | 		for (int i = 0;i < mid.size();i++) {
65 | 			root = create(root, mid[i]);
66 | 		}
67 | 		previsit(root, pre);
68 | 		sort(mid.begin(), mid.end());
69 | 		print_all(pre);
70 | 		print_all(mid);
71 | 		for (int i = 0;i < n;i++) {
72 | 			Node* root_test = NULL;
73 | 			vector<int> mid_test;
74 | 			vector<int> pre_test;
75 | 			cin >> tmp;
76 | 			convert(tmp, mid_test);
77 | 			for (int i = 0;i < mid_test.size();i++) {
78 | 				root_test = create(root_test, mid_test[i]);
79 | 			}
80 | 			previsit(root_test, pre_test);
81 | 			sort(mid_test.begin(), mid_test.end());
82 | 			print_all(pre_test);
83 | 			print_all(mid_test);
84 | 			if (compare(mid, mid_test) && compare(pre, pre_test)) {
85 | 				cout << "YES" << endl;
86 | 			}
87 | 			else {
88 | 				cout << "NO" << endl;
89 | 			}
90 | 		}
91 | 	}
92 | }
93 | int main() {
94 | 	func();
95 | 	return 0;
96 | }
97 | 


--------------------------------------------------------------------------------
/代码/2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int months[13][2] = {
 4 | 	0,0,
 5 | 	31,31,
 6 | 	28,29,
 7 | 	31,31,
 8 | 	30,30,
 9 | 	31,31,
10 | 	30,30,
11 | 	31,31,
12 | 	31,31,
13 | 	30,30,
14 | 	31,31,
15 | 	30,30,
16 | 	31,31
17 | };
18 | int getyear(int year){
19 | 	if(year%400==0||(year%4==0&&year%100!=0)) return 1;
20 | 	else return 0;
21 | }
22 | struct date{
23 | 	int year;
24 | 	int month;
25 | 	int day;
26 | 	date(int y,int m,int d):year(y),month(m),day(d)
27 | 	{}
28 | 	void print_date(){
29 | 		cout<<year<<" "<<month<<" "<<day<<endl; 
30 | 	}
31 | 	int  getdays(date next){
32 | 		int cnt =0;
33 | 		int index = getyear(year);
34 | 		while(*this !=next){	
35 | 			cnt++;
36 | 			day++;
37 | 			if(day>months[month][index]){
38 | 				day = 1;
39 | 				month++;
40 | 				if(month>12){
41 | 					month = 1;
42 | 					year++;
43 | 					index = getyear(year);
44 | 				}
45 | 			}
46 | 		}
47 | 		return cnt;		
48 | 	}
49 | 	bool operator <(date d){
50 | 		if(year<d.year) return true;
51 | 		if(year>d.year) return false;
52 | 		if(month<d.month) return true;
53 | 		if(month>d.month) return false;
54 | 		if(day<d.day) return true;
55 | 		if(day>d.day) return false;
56 | 		return false;
57 | 	}
58 | 	bool operator !=(date d){
59 | 		if(year==d.year&&month==d.month&&day==d.day) return false;
60 | 		else return true;
61 | 	}
62 | };
63 | void func(){
64 | 	int year,month,day;
65 | 	scanf("%4d%2d%2d",&year,&month,&day);
66 | 	date d1(year,month,day);
67 | 	scanf("%4d%2d%2d",&year,&month,&day);
68 | 	date d2(year,month,day);
69 | 	int cnt;
70 | 	if(d1<d2)
71 | 		cnt = d1.getdays(d2); 
72 | 	else 
73 | 		cnt = d2.getdays(d1); 
74 | 	cout<<cnt+1<<endl;
75 | }
76 | int main(){
77 | 	func();
78 | 	return 0;
79 | }
80 | 


--------------------------------------------------------------------------------
/代码/20-1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | using namespace std;
 4 | 
 5 | void func() {
 6 | 	string num1, num2;
 7 | 	while (cin >> num1 && cin >> num2) {
 8 | 		int sum = 0;
 9 | 		for (int i = 0;i < num1.length();i++) {
10 | 			for (int j = 0;j < num2.length();j++) {
11 | 				sum += (num1[i] - '0') * (num2[j] - '0');
12 | 			}
13 | 		}
14 | 		cout << sum << endl;
15 | 
16 | 	}
17 | }
18 | int main() {
19 | 	func();
20 | 	return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/代码/20.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<algorithm>
 4 | 
 5 | using namespace std;
 6 | void print_all(vector<int> res){
 7 | 	for (int i = 0;i < res.size();i++) {
 8 | 		cout << res[i] << " ";
 9 | 	}
10 | 	cout << endl;
11 | }
12 | vector<int> convert(int num) {
13 | 	num = abs(num);
14 | 	vector<int> res;
15 | 	while (num != 0) {
16 | 		res.push_back(num % 10);
17 | 		num = num / 10;
18 | 	}
19 | 	//print_all(res);
20 | 	return res;
21 | }
22 | 
23 | void func() {
24 | 	int num1, num2;
25 | 	while (cin >> num1 && cin >> num2) {
26 | 		bool f1 = (num1 < 0);
27 | 		bool f2 = (num2 < 0);
28 | 		int flag = 1;
29 | 		if ((!f1 && f2) || (f1 && !f2)) {
30 | 			flag = -1;
31 | 		}
32 | 		vector<int> tmp1 = convert(num1);
33 | 		vector<int> tmp2 = convert(num2);
34 | 		int sum = 0;
35 | 		for (int i = 0;i < tmp1.size();i++) {
36 | 			for (int j = 0;j < tmp2.size();j++) {
37 | 				sum += tmp1[i] * tmp2[j];
38 | 			}
39 | 		}
40 | 		sum = sum * flag;
41 | 		cout << sum << endl;
42 | 	}
43 | }
44 | int main() {
45 | 	func();
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/代码/21.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | #include<algorithm> 
 4 | 
 5 | using namespace std;
 6 | 
 7 | string IntToX(int num, int radix) {
 8 | 	string res = "";
 9 | 	do {
10 | 		int t = num % radix;
11 | 		if (t <= 9 && t >= 0) {
12 | 			res += t + '0';
13 | 		}
14 | 		else {
15 | 			res += t - 10 + '0';
16 | 		}
17 | 		num = num / radix;
18 | 	} while (num != 0);
19 | 	reverse(res.begin(), res.end());
20 | 	return res;
21 | }
22 | string add(string a, string b,int radix ) {
23 | 	reverse(a.begin(), a.end());
24 | 	reverse(b.begin(), b.end());
25 | 	int len_a = a.length();
26 | 	int len_b = b.length();
27 | 	a += string((50 - len_a) ,'0');
28 | 	b += string((50 - len_b), '0');
29 | 	int flag = 0;
30 | 	for (int i = 0;i < 50;i++) {
31 | 		int sum = a[i] + b[i] - '0' - '0' + flag;
32 | 		flag = 0;
33 | 		if (sum >= radix) {
34 | 			sum = sum - radix;
35 | 			flag = 1;
36 | 		}
37 | 		a[i] = sum + '0';
38 | 	}
39 | 	int len = len_a > len_b ? len_a : len_b;
40 | 	while (a[len] != '0') {
41 | 		len++;
42 | 	}
43 | 	string ans = a.substr(0, len);
44 | 	reverse(ans.begin(), ans.end());
45 | 	return ans;
46 | }
47 | void func() {
48 | 	int a, b, r;
49 | 	while (cin >> r >> a >> b) {
50 | 		string a1 = IntToX(a, r);
51 | 		string b1 = IntToX(b, r);
52 | 		string ans = add(a1, b1, r);
53 | 		cout << ans << endl;
54 | 	}
55 | }
56 | 
57 | int main() {
58 | 	func();
59 | 	return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/代码/22.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | #include<algorithm>
 4 | 
 5 | #define ll long long
 6 | using namespace std;
 7 | 
 8 | ll XToInt(string num, int radix) {
 9 | 	ll ans = 0;
10 | 	int len = num.length();
11 | 	for (int i = 0;i < len;i++) {
12 | 		if (num[i] >= '0' && num[i] <= '9') {
13 | 			ans = ans * radix + num[i] - '0';
14 | 		}
15 | 		else {
16 | 			ans = ans * radix + num[i] +10 - 'A';
17 | 		}
18 | 	}
19 | 	return ans;
20 | }
21 | string IntToX(ll num, int radix) {
22 | 	string res = "";
23 | 	do{
24 | 		int t = num % radix;
25 | 		if (t >= 0 && t <= 9) {
26 | 			res += t + '0';
27 | 		}
28 | 		else {
29 | 			res += t + 'A' - 10;
30 | 		}
31 | 		num = num / radix; 
32 | 	} while (num != 0);
33 | 	reverse(res.begin(), res.end());
34 | 	return res;
35 | }
36 | void func() {
37 | 	int a, b;
38 | 	string n;
39 | 	cin >> a >> n >> b;
40 | 	ll num = XToInt(n, a);
41 | 	string ans = IntToX(num, b);
42 | 	cout << ans << endl;
43 | }
44 | int main() {
45 | 	func();
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/代码/23.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int gcd(int a, int b) {
 6 | 	if (b == 0) return a;
 7 | 	return gcd(b, a % b);
 8 | }
 9 | void func() {
10 | 	int a, b;
11 | 	while (cin >> a >> b) {
12 | 		int ans = gcd(a, b);
13 | 		cout << ans << endl;
14 | 	}
15 | }
16 | 
17 | int main() {
18 | 	func();
19 | 	return 0;
20 | }


--------------------------------------------------------------------------------
/代码/24.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std; 
 3 | int gcd(int a, int b) {
 4 | 	if (b == 0) return a;
 5 | 	return gcd(b, a % b);
 6 | }
 7 | 
 8 | void func() {
 9 | 	int a, b;
10 | 	while (cin >> a >> b) {
11 | 		int max = gcd(a, b);
12 | 		int res = a / max * b;
13 | 		cout << res << endl;
14 | 	}
15 | }
16 | int main() {
17 | 	func();
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/代码/25.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<math.h>
 3 | using namespace std;
 4 | 
 5 | bool IsPrime(int n) {
 6 | 	if (n <= 1) return false;
 7 | 	int len = sqrt(n);
 8 | 	for (int i = 2;i <= len;i++) {
 9 | 		if (n % i == 0) {
10 | 			return false;
11 | 		}
12 | 	}
13 | 	return true;
14 | }
15 | 
16 | void func() {
17 | 	int n;
18 | 	while (cin >> n) {
19 | 		bool res = IsPrime(n);
20 | 		if (res) {
21 | 			cout << "yes" << endl;
22 | 		}
23 | 		else {
24 | 			cout << "no" << endl;
25 | 		}
26 | 	}
27 | }
28 | int main() {
29 | 	func();
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/代码/26.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<math.h>
 3 | #include<vector> 
 4 | using namespace std;
 5 | 
 6 | void func(int n) {
 7 | 	if (n < 12) {
 8 | 		cout << -1 << endl;
 9 | 		return;
10 | 	}
11 | 	vector<int> tmp(n, 0);
12 | 	for (int i = 2;i < n;i++) {
13 | 		if (tmp[i] == 0) {
14 | 			for (int j = i * i;j < n;j=j+i) {
15 | 				tmp[j] = 1;
16 | 			}
17 | 			if (i % 10 == 1) {
18 | 				cout << i << " ";
19 | 			}
20 | 		}
21 | 	}
22 | 	cout << endl;
23 | }
24 | int main() {
25 | 	int n;
26 | 	while (cin >> n) {
27 | 		func(n);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/代码/27.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/27.cpp


--------------------------------------------------------------------------------
/代码/28.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | using namespace std;
 4 | 
 5 | struct mytype {
 6 | 	int number;
 7 | 	int count;
 8 | 	mytype(int num, int c) {
 9 | 		number = num;
10 | 		count = c;
11 | 	}
12 | };
13 | vector<int> tmp(1001, 0);
14 | void proprocess() {
15 | 	for (int i = 2;i < 1000;i++) {
16 | 		if (tmp[i] == 0) {
17 | 			for (int j = i * i;j <= 1000;j = j + i) {
18 | 				tmp[i] = 1;
19 | 			}
20 | 		}
21 | 	}
22 | }
23 | vector<mytype> find_factor(int n) {
24 | 	vector<mytype> res;
25 | 	int another = n;
26 | 	for (int i = 2;i <= n;i++) {
27 | 		if (tmp[i] == 0) {
28 | 			int count = 0;
29 | 			while (another % i == 0) {
30 | 				count++;
31 | 				another = another / i;
32 | 			}
33 | 			if (count != 0) {
34 | 				res.push_back(mytype(i, count));
35 | 			}
36 | 		}
37 | 	}
38 | 	return res;
39 | }
40 | int getNum(int n, int p) {
41 | 	int ans = 0;
42 | 	for (int i = p;i <= n;i = i * p) {
43 | 		ans += n / i;
44 | 	}
45 | 	return ans;
46 | }
47 | void func() {
48 | 	int n, a;
49 | 	cin >> n >> a;
50 | 	vector<mytype> ans = find_factor(a);
51 | 	int min=100000;
52 | 	int len = ans.size();
53 | 	for (int i = 0;i < len;i++) {
54 | 		int num = getNum(n, ans[i].number);
55 | 		int count = num / ans[i].count;
56 | 		min = min > count ? count : min;
57 | 	}
58 | 	cout << min << endl;
59 | }
60 | int main() {
61 | 	func();
62 | 	return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/代码/29.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/29.cpp


--------------------------------------------------------------------------------
/代码/3.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int dates[3002][13][32];
 4 | char NameofWeek[7][20] =
 5 | {
 6 | 	"Sunday",
 7 | 	"Monday",
 8 | 	"Tuesday",
 9 | 	"Wednesday",
10 | 	"Thursday",
11 | 	"Friday",
12 | 	"Saturday"
13 | };
14 | int dayOfMonth[13][2] = {
15 | 	0,0,
16 | 	31,31,
17 | 	28,29,
18 | 	31,31,
19 | 	30,30,
20 | 	31,31,
21 | 	30,30,
22 | 	31,31,
23 | 	31,31,
24 | 	30,30,
25 | 	31,31,
26 | 	30,30,
27 | 	31,31
28 | };
29 | char NameofMonth[13][20] =
30 | {
31 | 	"",
32 | 	"January",
33 | 	"February",
34 | 	"March",
35 | 	"April",
36 | 	"May",
37 | 	"June",
38 | 	"July",
39 | 	"August",
40 | 	"September",
41 | 	"October",
42 | 	"November",
43 | 	"December"
44 | };
45 | int isleap(int year) {
46 | 	if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
47 | 		return 1;
48 | 	return 0;
49 | }
50 | struct date {
51 | 	int year;
52 | 	int month;
53 | 	int day;
54 | 	int cnt;
55 | 	date(int y, int m, int d, int c) :year(y), month(m), day(d), cnt(c) {}
56 | 	void nextday() {
57 | 		int index = isleap(year);
58 | 		while (year < 3001) {
59 | 			dates[year][month][day] = cnt;
60 | 			day++;
61 | 			cnt++;
62 | 			if (day > dayOfMonth[month][index]) {
63 | 				day = 1;
64 | 				month++;
65 | 				if (month > 12) {
66 | 					month = 1;
67 | 					year++;
68 | 					index = isleap(year);
69 | 				}
70 | 			}
71 | 		}
72 | 	}
73 | };
74 | int main() {
75 | 	date start(1000, 1, 1, 0);
76 | 	start.nextday();
77 | 	int year, month, day;
78 | 	char tmp[10];
79 | 	scanf("%d %s %d", &day, tmp, &year);
80 | 	for (int i = 1;i < 13;i++) {
81 | 		if (strcmp(NameofMonth[i], tmp) == 0) {
82 | 			month = i;
83 | 			break;
84 | 		}
85 | 	}
86 | 	int days = dates[2020][1][24] - dates[year][month][day];
87 | 	printf("%s", NameofWeek[(12-days % 7) % 7]);
88 | 	return 0;
89 | }
90 | 


--------------------------------------------------------------------------------
/代码/30.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | 
 6 | string add(string a, string b) {
 7 | 	reverse(a.begin(), a.end());
 8 | 	reverse(b.begin(), b.end());
 9 | 	int len_a = a.length();
10 | 	int len_b = b.length();
11 | 	a += string(10010 - len_a, '0');
12 | 	b += string(10010 - len_b, '0');
13 | 	int max = len_a > len_b ? len_a : len_b;
14 | 	max += 2;
15 | 	int flag = 0;
16 | 	for (int i = 0;i < max;i++) {
17 | 		int sum = a[i] - '0' + b[i] - '0' + flag;
18 | 		flag = 0;
19 | 		if (sum >= 10) {
20 | 			sum -= 10;
21 | 			flag = 1;
22 | 		}
23 | 		a[i] = sum + '0';
24 | 	}
25 | 	int len = max - 2;
26 | 	while (a[len] != '0') {
27 | 		len++;
28 | 	}
29 | 	string ans = a.substr(0, len);
30 | 	reverse(ans.begin(), ans.end());
31 | 	return ans;
32 | 
33 | }
34 | void func() {
35 | 	string a, b;
36 | 	while (cin >> a >> b) {
37 | 		string ans = add(a, b);
38 | 		cout << ans << endl;;
39 | 	}
40 | }
41 | int main() {
42 | 	func();
43 | 	return 0;
44 | }


--------------------------------------------------------------------------------
/代码/31.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std; 
 4 | struct bigdigit {
 5 | 	int digit[1000];
 6 | 	int size;
 7 | 	bigdigit() {
 8 | 		for (int i = 0;i < 1000;i++) {
 9 | 			digit[i] = 0;
10 | 		}
11 | 		size = 0;
12 | 	}
13 | 	void set(int x) {
14 | 		do {
15 | 			int t = x % 1000;
16 | 			digit[size] = t;
17 | 			size++;
18 | 			x = x / 1000;
19 | 		} while (x != 0);
20 | 	}
21 | 	void output() {
22 | 		for (int i = size - 1;i >= 0;i--) {
23 | 			if (i == size - 1) {
24 | 				printf("%d", digit[i]);
25 | 			}
26 | 			else {
27 | 				printf("%03d", digit[i]);
28 | 			}
29 | 		}
30 | 		cout << endl;
31 | 	}
32 | };
33 | 
34 | void func() {
35 | 	int n;
36 | 	while (cin >> n) {
37 | 		bigdigit s;
38 | 		s.set(1);
39 | 		for (int i = 1;i <= n;i++) {
40 | 			int flag = 0;
41 | 			for (int j = 0;j < s.size;j++) {
42 | 				int sum = s.digit[j] * i + flag;
43 | 				flag = sum / 1000;
44 | 				sum = sum % 1000;
45 | 				s.digit[j] = sum;
46 |  			}
47 | 			if (flag != 0) {
48 | 				s.size++;
49 | 				s.digit[s.size-1] = flag;
50 | 			}
51 | 		}
52 | 		s.output();
53 | 	}
54 | }
55 | int main() {
56 | 	func();
57 | 	return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/代码/32.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/32.cpp


--------------------------------------------------------------------------------
/代码/33.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream> 
 2 | #include<algorithm>
 3 | #include<vector>
 4 | 
 5 | using namespace std;
 6 | 
 7 | struct union_find {
 8 | 	vector<int> tree;
 9 | 	int size;
10 | 	union_find(int n) {
11 | 		tree = vector<int>(n+1);
12 | 		for (int i = 1;i <= n;i++) {
13 | 			tree[i] = i;
14 | 		}
15 | 		size = n;
16 | 	}
17 | 	int findRoot(int p) {
18 | 		if (tree[p] == p) {
19 | 			return p;
20 | 		}
21 | 		else {
22 | 			int tmp = findRoot(tree[p]);
23 | 			tree[p] = tmp;
24 | 			return tmp;
25 | 		}
26 | 	}
27 | 	bool isConnection(int p, int q) {
28 | 		int pRoot = findRoot(p);
29 | 		int qRoot = findRoot(q);
30 | 		return (pRoot == qRoot);
31 | 	}
32 | 	void unions(int p, int q) {
33 | 		int pRoot = findRoot(p);
34 | 		int qRoot = findRoot(q);
35 | 		if (pRoot != qRoot) {
36 | 			tree[pRoot] = qRoot;
37 | 			size--;
38 | 		}
39 | 	}
40 | };
41 | 
42 | void func() {
43 | 	int n, m;
44 | 	while (cin >> n >> m) {
45 | 		if (n == 0) break;
46 | 		union_find s(n);
47 | 		for (int i = 0;i < m;i++) {
48 | 			int p, q;
49 | 			cin >> p >> q;
50 | 			s.unions(p, q);
51 | 		}
52 | 		cout << s.size - 1 << endl;
53 | 	}
54 | }
55 | int main() {
56 | 	func();
57 | 	return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/代码/34-1.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/34-1.cpp


--------------------------------------------------------------------------------
/代码/34.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | const int N = 10000001;
 4 | using namespace std;
 5 | int tree[N];
 6 | int sum[N];
 7 | int Max;
 8 | int findRoot(int p) {
 9 | 	if (tree[p] == p) {
10 | 		return p;
11 | 	}
12 | 	else {
13 | 		int tmp = findRoot(tree[p]);
14 | 		tree[p] = tmp;
15 | 		return tmp;
16 | 	}
17 | }
18 | void unions(int p, int q) {
19 | 	int pRoot = findRoot(p);
20 | 	int qRoot = findRoot(q);
21 | 	if (pRoot != qRoot) {
22 | 		tree[pRoot] = qRoot;
23 | 		sum[qRoot] += sum[pRoot];
24 | 		Max = Max > sum[qRoot] ? Max : sum[qRoot];
25 | 	}
26 | }
27 | 
28 | void func() {
29 | 	int n;
30 | 	while (cin >> n) {
31 | 		for (int i = 1;i <= N;i++) {
32 | 			tree[i] = i;
33 | 			sum[i] = 1;
34 | 		}
35 | 		Max = 1;
36 | 		for (int i = 0;i < n;i++) {
37 | 			int p, q;
38 | 			cin >> p >> q;
39 | 			unions(p, q);
40 | 		}
41 | 		cout << Max << endl;
42 | 	}
43 | }
44 | int main() {
45 | 	func();
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/代码/35-1.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/35-1.cpp


--------------------------------------------------------------------------------
/代码/35.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/35.cpp


--------------------------------------------------------------------------------
/代码/36.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/36.cpp


--------------------------------------------------------------------------------
/代码/37-1.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/37-1.cpp


--------------------------------------------------------------------------------
/代码/37.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | const int Max = 1000000;
 6 | 
 7 | int ans[120][120];
 8 | 
 9 | void func() {
10 | 	int n, m;
11 | 	while (cin >> n >> m) {
12 | 		if (n == 0 && m == 0) {
13 | 			break;
14 | 		}
15 | 		for (int i = 1;i <= n;i++) {
16 | 			for (int j = 1;j <= n;j++) {
17 | 				ans[i][j] = Max;
18 | 			}
19 | 		}
20 | 		for (int i = 0;i < m;i++) {
21 | 			int p, q, cost;
22 | 			cin >> p >> q >> cost;
23 | 			ans[p][q] = cost;
24 | 			ans[q][p] = cost;
25 | 		}
26 | 		for (int k = 1;k <= n;k++) {
27 | 			for (int i = 1;i <= n;i++) {
28 | 				for (int j = 1;j <= n;j++) {
29 | 					if (ans[i][k] + ans[k][j] < ans[i][j]) {
30 | 						ans[i][j] = ans[i][k] + ans[k][j];
31 | 					}
32 | 				}
33 | 			}
34 | 		}
35 | 		cout << ans[1][n] << endl;
36 | 
37 | 	}
38 | }
39 | 
40 | int main() {
41 | 	func();
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/代码/38.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<vector>
 3 | 
 4 | using namespace std;
 5 | 
 6 | struct Edge {
 7 | 	int to;
 8 | 	int cost;
 9 | 	int len;
10 | };
11 | int dist[1001];
12 | int cost[1001];
13 | bool marked[1001];
14 | vector<Edge> edge[1000];
15 | 
16 | void func() {
17 | 	int n, m;
18 | 	while (scanf("%d %d",&n,&m)) {
19 | 		if (n == 0 && m == 0) {
20 | 			break;
21 | 		}
22 | 		for (int i = 1;i <= n;i++) {
23 | 			dist[i] = -1;
24 | 			marked[i] = false;
25 | 			edge[i].clear();
26 | 		}
27 | 		for (int i = 0;i < m;i++) {
28 | 			int a, b, d, p;
29 | 			scanf("%d %d %d %d", &a, &b, &d, &p);
30 | 			Edge tmp;
31 | 			tmp.cost = p;
32 | 			tmp.len = d;
33 | 			tmp.to = a;
34 | 			edge[b].push_back(tmp);
35 | 			tmp.to = b;
36 | 			edge[a].push_back(tmp);
37 | 		}
38 | 		int s, t;
39 | 		scanf("%d %d", &s, &t);
40 | 		int  v = s;
41 | 
42 | 		marked[v] = true;
43 | 		dist[v] = 0;
44 | 		cost[v] = 0;
45 | 		for (int i = 0;i < n - 1;i++) {
46 | 			for (int j = 0;j < edge[v].size();j++) {
47 | 				int to = edge[v][j].to;
48 | 				int newLen = dist[v] + edge[v][j].len;
49 | 				int newCost = cost[v] + edge[v][j].cost;
50 | 				if (marked[to]) continue;
51 | 				if (dist[to] == -1 || newLen <dist[to] || (dist[to] == newLen && newCost < cost[to])) {
52 | 					dist[to] = newLen;
53 | 					cost[to] = newCost;
54 | 				}
55 | 			}
56 | 			int minLen=100000000;
57 | 			int minCost= 100000000;
58 | 			for (int j = 1;j <= n;j++) {
59 | 				if (marked[j] || dist[j] == -1) continue;
60 | 				if (dist[j] < minLen || (dist[j] == minLen && cost[j] < minCost)) {
61 | 					minLen = dist[j];
62 | 					minCost = cost[j];
63 | 					v = j;
64 | 				}
65 | 			}
66 | 			marked[v] = true;
67 | 			if (v == t) {
68 | 				break;
69 | 			}
70 | 		}
71 | 		printf("%d %d\n", dist[t], cost[t]);
72 | 	}
73 | }
74 | int main() {
75 | 	func();
76 | 	return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/代码/39.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<queue>
 4 | 
 5 | using namespace std;
 6 | 
 7 | vector<int> edge[101];
 8 | int indegree[101];
 9 | queue<int> Q;
10 | void func() {
11 | 	int n, m;
12 | 	while (cin >> n >> m && n != 0) {
13 | 		while (!Q.empty()) {
14 | 			Q.pop();
15 | 		}
16 | 		for (int i = 0;i < n;i++) {
17 | 			indegree[i] = 0;
18 | 			edge[i].clear();
19 | 		}
20 | 		for (int i = 0;i < m;i++) {
21 | 			int x, y;
22 | 			cin >> x >> y;
23 | 			edge[x].push_back(y);
24 | 			indegree[y]++;
25 | 		}
26 | 		for (int i = 0;i < n;i++) {
27 | 			if (indegree[i] == 0) {
28 | 				Q.push(i);
29 | 			}
30 | 		}
31 | 		int size = 0;
32 | 		while (!Q.empty()) {
33 | 			int v = Q.front();
34 | 			Q.pop();
35 | 			size++;
36 | 			for (int i = 0;i < edge[v].size();i++) {
37 | 				int to = edge[v][i];
38 | 				indegree[to]--;
39 | 				if (indegree[to] == 0) {
40 | 					Q.push(to);
41 | 				}
42 | 			}
43 | 		}
44 | 		if (size == n) {
45 | 			cout << "YES" << endl;
46 | 		}
47 | 		else {
48 | 			cout << "NO" << endl;
49 | 		}
50 | 	}
51 | }
52 | int main() {
53 | 	func();
54 | 	return 0;
55 | }


--------------------------------------------------------------------------------
/代码/4.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | 
 4 | using namespace std;
 5 | int main(){
 6 | 	int n;
 7 | 	int grade;
 8 | 	int res;
 9 | 	while(cin>>n){
10 | 		if(n==0) break;
11 | 		vector<int> a(101,0);
12 | 		for(int i =0;i<n;i++){
13 | 			cin>>grade;
14 | 			a[grade]++;
15 | 		}
16 | 		cin>>res;
17 | 		cout<<a[res]<<endl;
18 | 	}
19 | 	return 0;
20 | } 
21 | 
22 | 


--------------------------------------------------------------------------------
/代码/40.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #define ll long long
 3 | using namespace std;
 4 | void func() {
 5 | 	int n;
 6 | 	cin >> n;
 7 | 	ll f1 = 1;
 8 | 	ll f2 = 2;
 9 | 	int len = 3;
10 | 	if (n <= 1) {
11 | 		cout << 1 << endl;
12 | 		return;
13 | 	}
14 | 	while (len <= n) {
15 | 		ll tmp = f2;
16 | 		f2 = f1 + f2;
17 | 		f1 = tmp;
18 | 		len++;
19 | 	}
20 | 	cout << f2 << endl;
21 | }
22 | int main() {
23 | 	ios::sync_with_stdio(false);
24 | 	cin.tie(0);
25 | 	func();
26 | }
27 | 


--------------------------------------------------------------------------------
/代码/41.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #define ll long long
 3 | 
 4 | using namespace std;
 5 | 
 6 | ll f[21];
 7 | 
 8 | void process() {
 9 | 	f[1] = 0;
10 | 	f[2] = 1;
11 | 	for (int i = 3;i <= 20;i++) {
12 | 		f[i] = (i - 1) * (f[i - 1] + f[i - 2]);
13 | 	}
14 | }
15 | void func() {
16 | 	process();
17 | 	int n;
18 | 	while (cin >> n) {
19 | 		cout << f[n] << endl;
20 | 	}
21 | }
22 | 
23 | int main() {
24 | 	ios::sync_with_stdio(false);
25 | 	cin.tie(0);
26 | 	func();
27 | }
28 | 


--------------------------------------------------------------------------------
/代码/42.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int f[30];
 6 | int a[30];
 7 | void func() {
 8 | 	int k;
 9 | 	while (cin >> k) {
10 | 		for (int i = 1;i <= k;i++) {
11 | 			cin >> a[i];
12 | 		}
13 | 		f[1] = 1;
14 | 		for (int i = 2;i <= k;i++) {
15 | 			int max = 1;
16 | 			for (int j = 1;j < i;j++) {
17 | 				if (a[j] >= a[i]) {
18 | 					max = max > f[j] + 1 ? max : f[j] + 1;
19 | 				}
20 | 			}
21 | 			f[i] = max;
22 | 		}
23 | 		int ans = 0;
24 | 		for (int i = 1;i <= k;i++) {
25 | 			ans = ans > f[i] ? ans : f[i];
26 | 		}
27 | 		cout << ans << endl;
28 | 			
29 | 	}
30 | }
31 | 
32 | int main() {
33 | 	ios::sync_with_stdio(false);
34 | 	cin.tie(0);
35 | 	func();
36 | 	return 0;
37 | }


--------------------------------------------------------------------------------
/代码/43.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | 
 4 | using namespace std;
 5 | int max(int a, int b) {
 6 | 	return (a > b ? a : b);
 7 | }
 8 | int dp[120][120];
 9 | 
10 | void func() {
11 | 	string a, b;
12 | 	cin >> a >> b;
13 | 	int len1 = a.length();
14 | 	int len2 = b.length();
15 | 	for (int i = 0;i < len1;i++) {
16 | 		dp[i][0] = 0;
17 | 	}
18 | 	for (int i = 0;i < len2;i++) {
19 | 		dp[0][i] = 0;
20 | 	}
21 | 	for (int i = 1;i<=len1;i++) {
22 | 		for (int j = 1;j <= len2;j++) {
23 | 			if (a[i-1] == b[j-1]) {
24 | 				dp[i][j] = dp[i - 1][j - 1] + 1;
25 | 			}
26 | 			else {
27 | 				dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
28 | 			}
29 | 		}
30 | 	}
31 | 	cout << dp[len1][len2] << endl;
32 | }
33 | 
34 | int main() {
35 | 	ios::sync_with_stdio(false);
36 | 	cin.tie(0);
37 | 	func();
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/代码/44.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | 
 5 | int dp[1020][2010];
 6 | int a[2010];
 7 | 
 8 | int min(int a, int b) {
 9 | 	return a < b ? a : b;
10 | }
11 | void process() {
12 | 	for (int j = 0;j < 2010;j++) {
13 | 		dp[0][j] = 0;
14 | 	}
15 | }
16 | 
17 | void func() {
18 | 	int n, k;
19 | 	process();
20 | 	while (cin >> n >> k) {
21 | 		for (int i = 1;i <= n;i++) {
22 | 			cin >> a[i];
23 | 		}
24 | 		sort(a + 1, a + n + 1);
25 | 		for (int i = 1;i <= k;i++) {
26 | 			for (int j = 2 * i;j <= n;j++) {
27 | 				int tmp = (a[j] - a[j - 1]) * (a[j] - a[j - 1]);
28 | 				if (2 * i == j) {
29 | 					dp[i][j] = dp[i - 1][j - 2]+ tmp;
30 | 				}
31 | 				else {
32 | 					dp[i][j] = min(dp[i - 1][j - 2] + tmp, dp[i][j - 1]);
33 | 				}
34 | 			}
35 | 		}
36 | 		cout << dp[k][n] << endl;
37 | 	}
38 | }
39 | int main() {
40 | 	ios::sync_with_stdio(false);
41 | 	cin.tie(0);
42 | 	func();
43 | 	return 0;
44 | }


--------------------------------------------------------------------------------
/代码/45-1.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define OFFSET 2000 
 3 | 
 4 | int dp[101][4001]; 
 5 | int list[101]; 
 6 | #define INF 0x7fffffff 
 7 | int main () {
 8 | 	int T;
 9 | 	int cas = 0; 
10 | 	scanf ("%d",&T); 
11 | 	while (T -- != 0) { 
12 | 		int n;
13 | 		scanf ("%d",&n);
14 | 		bool HaveZero = false; 
15 | 		int cnt = 0;
16 | 		for (int i = 1; i <= n; i ++) { 
17 | 			scanf ("%d",&list[++ cnt]);
18 | 			if (list[cnt] == 0) {
19 | 				cnt --; 
20 | 				HaveZero = true; 
21 | 			}
22 | 		}
23 | 		n = cnt;
24 | 		for (int i = -2000; i <= 2000; i ++) {
25 | 			dp[0][i + OFFSET] = -INF;
26 | 		} 
27 | 		dp[0][0 + OFFSET] = 0; 
28 | 		for (int i = 1; i <= n; i ++) { 
29 | 			for (int j = -2000; j <= 2000; j ++) { 
30 | 				int tmp1 = -INF,tmp2 = -INF; 
31 | 				if (j + list[i] <= 2000 && dp[i - 1][j + list[i] + OFFSET] !=-INF) { 
32 | 					tmp1 = dp[i - 1][j + list[i] + OFFSET] + list[i];
33 | 				}
34 | 				if (j - list[i] >= -2000 && dp[i - 1][j - list[i] + OFFSET] !=-INF) { 
35 | 					tmp2 = dp[i - 1][j - list[i] + OFFSET] + list[i]; 
36 | 				}
37 | 				if (tmp1 < tmp2) {
38 | 					tmp1 = tmp2;
39 | 				} 
40 | 				if (tmp1 < dp[i - 1][j + OFFSET]) {
41 | 
42 | 					tmp1 = dp[i - 1][j + OFFSET];
43 | 				}
44 | 				dp[i][j + OFFSET] = tmp1;
45 | 			}
46 | 		}
47 | 		printf("Case %d: ",++ cas);
48 | 		if (dp[n][0 + OFFSET] == 0) { 
49 | 			puts( HaveZero == true ? "0" : "-1");
50 | 		} 
51 | 		else printf("%d\n",dp[n][0 + OFFSET] / 2);
52 | 	}
53 | 	return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/代码/45.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | 
 4 | using namespace std;
 5 | const int INF = 1000000;
 6 | const int OFFSET = 2000;
 7 | int dp[110][4010];
 8 | int list[101];
 9 | void process() {
10 | 	for (int j = -2000;j <= 2000;j++) {
11 | 		dp[0][j+OFFSET] = -INF;
12 | 	}
13 | 	dp[0][OFFSET] = 0;
14 | }
15 | 
16 | void func() {
17 | 	int t;
18 | 	cin >> t;
19 | 	for (int i = 1;i <= t;i++) {
20 | 		int n;
21 | 		cin >> n;
22 | 		bool Zero =false;
23 | 		int cnt = 0;
24 | 		for (int j = 1;j <= n;j++) {
25 | 			cin >> list[++cnt];
26 | 			if (list[cnt] == 0) {
27 | 				Zero = true;
28 | 				cnt--;
29 | 			}
30 | 		}
31 | 		n = cnt;
32 | 		process();
33 | 		for (int x = 1;x <= n;x++) {
34 | 			for (int y = -2000;y <= 2000;y++) {
35 | 				int tmp1 = -INF;
36 | 				int tmp2 = -INF;
37 | 				if (y - list[x] >= -2000 && dp[x - 1][y - list[x] + OFFSET] != -INF) {
38 | 					tmp1 = dp[x - 1][y - list[x] + OFFSET] + list[x];
39 | 				}
40 | 				if (y + list[x] <= 2000 && dp[x - 1][y + list[x] + OFFSET] != -INF) {
41 | 					tmp2 = dp[x - 1][y + list[x] + OFFSET] + list[x];
42 | 				}
43 | 				if (tmp2 > tmp1) {
44 | 					tmp1 = tmp2;
45 | 				}
46 | 				if (dp[x - 1][y + OFFSET] > tmp1) {
47 | 					tmp1 = dp[x - 1][y + OFFSET];
48 | 				}
49 | 				dp[x][y + OFFSET] = tmp1;
50 | 			}
51 | 		}
52 | 		
53 | 		cout << "Case " << i << ": ";
54 | 		if (dp[n][OFFSET] == 0) {
55 | 			if (Zero == true) {
56 | 				cout << 0 << endl;
57 | 			}
58 | 			else {
59 | 				cout << -1 << endl;
60 | 			}
61 | 		}
62 | 		else {
63 | 			cout << dp[n][OFFSET] / 2 << endl;
64 | 		}
65 | 	}
66 | }
67 | int main() {
68 | 	ios::sync_with_stdio(false);
69 | 	cin.tie(0);
70 | 	func();
71 | 	return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/代码/46.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/46.cpp


--------------------------------------------------------------------------------
/代码/47.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | int max(int a, int b) {
 5 | 	return (a > b ? a : b);	
 6 | }
 7 | int dp[1001];
 8 | int value[101];
 9 | int times[101];
10 | void func() {
11 | 	int T, M;
12 | 	while (cin >> T >> M) {
13 | 		for (int i = 1;i <= M;i++) {
14 | 			cin >> times[i] >> value[i];
15 | 		}
16 | 		for (int i = 0;i <= T;i++) {
17 | 			dp[i] = 0;
18 | 		}
19 | 		for (int i = 1;i <= M;i++) {
20 | 			for (int j = T;j>=times[i];j--) {
21 | 				dp[j] = max(dp[j], dp[j - times[i]] + value[i]);
22 | 			}
23 | 		}
24 | 		cout << dp[T] << endl;
25 | 	}
26 | }
27 | int main() {
28 | 	ios::sync_with_stdio(false);
29 | 	cin.tie(0);
30 | 	func();
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/代码/48.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | const int INF = 1000000000;
 4 | using namespace std;
 5 | int min(int a, int b) {
 6 | 	return a < b ? a : b;
 7 | }
 8 | int dp[10001];
 9 | 
10 | int P[501];
11 | int W[501];
12 | 
13 | void func() {
14 | 	int T;
15 | 	cin >> T;
16 | 	for (int t = 0;t < T;t++) {
17 | 		int E, F;
18 | 		cin >> E >> F;
19 | 		int N;
20 | 		cin >> N;
21 | 		int sub = F - E;
22 | 		for (int i = 1;i <= N;i++) {
23 | 			cin >> P[i] >> W[i];
24 | 		}
25 | 		for (int i = 1;i <= sub;i++) {
26 | 			dp[i] = INF;
27 | 		}
28 | 		dp[0] = 0;
29 | 		for (int i = 1;i <= N;i++) {
30 | 			for (int j = W[i]; j <= sub;j++) {
31 | 				if (dp[j - W[i]] != INF) {
32 | 					dp[j] = min(dp[j], dp[j - W[i]] + P[i]);
33 | 				}
34 | 			}
35 | 		}
36 | 		if (dp[sub] != INF) {
37 | 			cout << "The minimum amount of money in the piggy-bank is ";
38 | 			cout << dp[sub];
39 | 			cout << "." << endl;
40 | 		}
41 | 		else {
42 | 			cout << "This is impossible." << endl;
43 | 		}
44 | 	}
45 | }
46 | 
47 | int main() {
48 | 	ios::sync_with_stdio(false);
49 | 	cin.tie(0);
50 | 	func();
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/代码/49.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int max(int a, int b) {
 6 | 	return a > b ? a : b;
 7 | }
 8 | int dp[101];
 9 | int P[2001];
10 | int H[2001];
11 | void func() {
12 | 	int c;
13 | 	cin >> c;
14 | 	while (c--) {
15 | 		int n, m;
16 | 		cin >> n >> m;
17 | 		int p,h,k;
18 | 		int cnt = 0;
19 | 		for (int i = 1;i <= m;i++) {
20 | 			cin >> p >> h >> k;
21 | 			int c = 1;
22 | 			while (k - c > 0) {
23 | 				k -= c;
24 | 				P[++cnt] = c * p;
25 | 				H[cnt] = c * h;
26 | 				c *= 2;
27 | 			}
28 | 			P[++cnt] = k * p;
29 | 			H[cnt] = k * h;
30 | 		}
31 | 		for (int i = 0;i <= n;i++) {
32 | 			dp[i] = 0;
33 | 		}
34 | 		for (int i = 1;i <= cnt;i++) {
35 | 			for (int j = n;j >= P[i];j--) {
36 | 				dp[j] = max(dp[j], dp[j - P[i]] + H[i]);
37 | 			}
38 | 		}
39 | 		cout << dp[n]<<endl;
40 | 	}
41 | }
42 | int main() {
43 | 	ios::sync_with_stdio(false);
44 | 	cin.tie(0);
45 | 	func();
46 | 	return 0;
47 | }


--------------------------------------------------------------------------------
/代码/5-1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<algorithm>
 4 | 
 5 | using namespace std;
 6 | bool cmp(int a, int b) {
 7 | 	return a > b;
 8 | }
 9 | void func() {
10 | 	int n, m;
11 | 	while(scanf ("%d %d",&n,&m) != EOF){
12 | 		vector<int> a(n);
13 | 		for (int i = 0;i < n;i++) {
14 | 			scanf("%d",&a[i]);
15 | 		}
16 | 		sort(a.begin(), a.end(), cmp);
17 | 		for (int i = 0;i < m-1;i++) {
18 | 			printf("%d ",a[i]);
19 | 		}
20 | 		printf("%d",a[m-1]);
21 | 		printf("\n");
22 | 	}
23 | }
24 | int main() {
25 | 	func();
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/代码/5-2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<stdio.h>
 4 | #define OFFSET 500000
 5 | using namespace std;
 6 | 
 7 | vector<int> a(1000001, 0);
 8 | void func() {
 9 | 	int n, m;
10 | 	while (scanf ("%d %d",&n,&m) != EOF) {
11 | 		int temp;
12 | 		for (int i = 0;i < n;i++) {
13 | 			scanf("%d",&temp);
14 | 			a[temp + OFFSET] =  1;
15 | 		}
16 | 		for (int i = 500000; i >= -500000; i --) { 
17 | 			if (a[i + OFFSET] == 1) { 
18 | 				printf("%d",i); 
19 | 				m --; 
20 | 				if (m != 0) printf(" "); 
21 | 			
22 | 				else {
23 | 					printf("\n"); 
24 | 					break;
25 | 				}
26 | 			}
27 | 		}
28 | 	}
29 | }
30 | int main() {
31 | 	func();
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/代码/5-3.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define OFFSET 500000
 3 | int Hash[1000001]; 
 4 | int main () {
 5 | 	int n , m;
 6 | 	while (scanf ("%d%d",&n,&m) != EOF) {
 7 | 		for (int i = -500000; i <= 500000; i ++) {
 8 | 			Hash[i + OFFSET] = 0;
 9 | 		} 
10 | 		for (int i = 1; i <= n; i ++) {
11 | 			int x;
12 | 			scanf ("%d",&x);
13 | 			Hash[x + OFFSET] = 1; 
14 | 		}
15 | 		for (int i = 500000; i >= -500000; i --) { 
16 | 			if (Hash[i + OFFSET] == 1) { 
17 | 				printf("%d",i); 
18 | 				m --; 
19 | 				if (m != 0) printf(" "); 
20 | 			
21 | 				else {
22 | 					printf("\n"); 
23 | 					break;
24 | 				}
25 | 			}
26 | 		}
27 | 	}
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/代码/50.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | void func(){
 6 | 	int n;
 7 | 	while (cin >> n) {
 8 | 		for (int x = 0;x <= 20;x++) {
 9 | 			for (int y = 0;y <= 33;y++) {
10 | 				int z = 100 - x - y;
11 | 				int sum; 
12 | 				// if (x * 5 * 3 + y * 3 * 3 + z <= n * 3)
13 | 				if (z % 3 == 0) {
14 | 					sum = 5 * x + 3 * y + z / 3;
15 | 				}
16 | 				else {
17 | 					sum = 5 * x + 3 * y + z / 3 + 1;
18 | 				}
19 | 				if (sum <= n) {
20 | 					cout << "x=" << x << ",";
21 | 					cout << "y=" << y << ",";
22 | 					cout << "z=" << z << endl;
23 | 				}
24 | 					
25 | 			}
26 | 		}
27 | 	}
28 | }
29 | int main() {
30 | 	func();
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/代码/51.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/51.cpp


--------------------------------------------------------------------------------
/代码/52.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/52.cpp


--------------------------------------------------------------------------------
/代码/53-1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int hanio(int x) {
 6 | 	if (x == 1) return 2;
 7 | 	else return hanio(x - 1) * 3 + 2;
 8 | }
 9 | 
10 | void func() {
11 | 	int n;
12 | 	while(cin>>n){
13 | 		int ans = hanio(n);
14 | 		cout << ans << endl;
15 | 	}
16 | }
17 | int main() {
18 | 	ios::sync_with_stdio(false);
19 | 	cin.tie(0);
20 | 	func();
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/代码/53.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int tmp[36];
 5 | void process() {
 6 | 	tmp[1] = 2;
 7 | 	for (int i = 2;i <= 35;i++) {
 8 | 		tmp[i] = tmp[i - 1] * 3 + 2;
 9 | 	}
10 | }
11 | void func() {
12 | 	int n;
13 | 	process(); 
14 | 	while (cin >> n) {
15 | 		cout << tmp[n] << endl;
16 | 	}
17 | }
18 | int main() {
19 | 	ios::sync_with_stdio(false);
20 | 	cin.tie(0);
21 | 	func();
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/代码/54.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | int ans[30];
 5 | bool marked[30];
 6 | int n;
 7 | bool IsPrime(int num) {
 8 | 	if (num == 2) return true;
 9 | 	int maxn = num / 2 + 1;
10 | 	for (int i = 2;i <= maxn;i++) {
11 | 		if (num % i == 0) {
12 | 			return false;
13 | 		}
14 | 	}
15 | 	return true;
16 | }
17 | void CheckAndPrint() {
18 | 	if (IsPrime(ans[1] + ans[n])) {
19 | 		for (int i = 1;i < n;i++) {
20 | 			cout << ans[i] << " ";
21 | 		}
22 | 		cout << ans[n];
23 | 		cout << endl;
24 | 	}
25 | }
26 | void DFS(int num) {
27 | 	if (num > 1) {
28 | 		if (!IsPrime(ans[num] + ans[num - 1])) {
29 | 			return;
30 | 		}
31 | 		if (num == n) {
32 | 			CheckAndPrint();
33 | 			return;
34 | 		}
35 | 	}
36 | 	for (int i = 2;i <= n;i++) {
37 | 		if (!marked[i]) {
38 | 			ans[num + 1] = i;
39 | 			marked[i] = true;
40 | 			DFS(num + 1);
41 | 			marked[i] = false;
42 | 		}
43 | 	}
44 | }
45 | void func() {
46 | 	int cnt = 1;
47 | 	while (cin >> n) {
48 | 		cout << "Case " << cnt << ":" << endl;
49 | 		cnt++;
50 | 		ans[1] = 1;
51 | 		for (int i = 2;i <= n;i++) {
52 | 			marked[i] = false;
53 | 		}
54 | 		DFS(1);
55 | 		cout << endl;
56 | 	}
57 | }
58 | int main() {
59 | 	func();
60 | 	return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/代码/55.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | bool marked[101][101];
 5 | int a[101][101];
 6 | int ans;
 7 | int m, n;
 8 | 
 9 | int go[8][2] = {
10 | 	1,0,
11 | 	-1,0,
12 | 	0,1,
13 | 	0,-1, 
14 | 	1,1,
15 | 	1,-1,
16 | 	-1,1,
17 | 	-1,-1
18 | };
19 | bool leagl(int i, int j) {
20 | 	if (i<1 || i>m)return false;
21 | 	if (j<1 || j>n)return false;
22 | 	return true;
23 | }
24 | void DFS(int i, int j) {
25 | 	for (int k = 0;k < 8;k++) {
26 | 		int newi = i + go[k][0];
27 | 		int newj = j + go[k][1];
28 | 		if (leagl(newi, newj)&&a[newi][newj]==1&& !marked[newi][newj]) {
29 | 			marked[newi][newj] = true;
30 | 			DFS(newi, newj);
31 | 		}
32 | 	}
33 | }
34 | void func() {
35 | 	char tmp;
36 | 	while (cin >> m >> n) {
37 | 		if (m == 0)break;
38 | 		ans = 0;
39 | 		for (int i = 1;i <= m;i++) {
40 | 			for (int j = 1;j <= n;j++) {
41 | 				marked[i][j] = false;
42 | 				cin>>tmp;
43 | 				if (tmp == '@') {
44 | 					a[i][j] = 1;
45 | 				}
46 | 				else {
47 | 					a[i][j] = 0;
48 | 				}
49 | 			}
50 | 		}
51 | 		for (int i = 1;i <= m;i++) {
52 | 			for (int j = 1;j <= n;j++) {
53 | 				if (marked[i][j] == false && a[i][j] == 1) {
54 | 					marked[i][j] = true;
55 | 					DFS(i, j);
56 | 					ans++;
57 | 				}
58 | 			}
59 | 		}
60 | 		cout << ans << endl;
61 | 	}
62 | }
63 | int main() {
64 | 	func();
65 | 	return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/代码/56.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/56.cpp


--------------------------------------------------------------------------------
/代码/57.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/57.cpp


--------------------------------------------------------------------------------
/代码/58.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/58.cpp


--------------------------------------------------------------------------------
/代码/6.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void func() {
 5 | 	int h;
 6 | 	cin >> h;
 7 | 	int max = 3 * h - 2;
 8 | 	int now = 2 * h - 2;
 9 | 	for (int i = 0;i < h;i++) {
10 | 		for (int j = 0;j < max;j++) {
11 | 			if (j < now) {
12 | 				cout << " ";
13 | 			}
14 | 			else {
15 | 				cout << "*";
16 | 			}
17 | 		}
18 | 		now -= 2;
19 | 		cout << endl;
20 | 	}
21 | }
22 | int main() {
23 | 	func();
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/代码/7.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | void border(int n,char inner,char  outer) {
 5 | 	cout << " ";
 6 | 	for (int i = 1;i < n - 1;i++) {
 7 | 		if ((n / 2) % 2 == 0) {
 8 | 			cout << inner;
 9 | 		}
10 | 		else {
11 | 			cout<<outer;
12 | 		}
13 | 	}
14 | 	cout << " " << endl;
15 | }
16 | void func() {
17 | 	int n;
18 | 	char center, outside;
19 | 	bool firstline = true;
20 | 	while (cin >> n >> center >> outside) {
21 | 		if (firstline == true) {
22 | 			firstline = false;
23 | 		}
24 | 		else {
25 | 			cout << endl;
26 | 		}
27 | 		if (n == 1) {
28 | 			cout << center;
29 | 		}
30 | 		else {
31 | 			border(n, center, outside);
32 | 			int now = n - 2;
33 | 			int dir = -1;
34 | 			int flag;
35 | 			for (int i = 0;i < n - 2;i++) {
36 | 				flag = ((n / 2) % 2 + 1) % 2;
37 | 				for (int j = 0;j < n;j++) {
38 | 					if (flag == 0) {
39 | 						cout << outside;
40 | 					}
41 | 					else {
42 | 						cout << center;
43 | 					}
44 | 					if (j < (n - now) / 2 || j >= (n + now) / 2 - 1) {
45 | 						flag = (flag + 1) % 2;
46 | 					}
47 | 				}
48 | 				cout << endl;
49 | 				now = now + dir * 2;
50 | 				if (now == 1) dir = 1;
51 | 			}
52 | 			border(n, center, outside);
53 | 		}
54 | 	}
55 | }
56 | int main() {
57 | 	func();
58 | 	return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/代码/8.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | using namespace std;
 4 | void func() {
 5 | 	int n;
 6 | 	while (cin >> n && n != 0) {
 7 | 		vector<int> a(n);
 8 | 		for (int i = 0;i < n;i++) {
 9 | 			cin >> a[i];
10 | 		}
11 | 		int x;
12 | 		cin >> x;
13 | 		int flag = 0;
14 | 		for (int i = 0;i < n;i++) {
15 | 			if (a[i] == x) {
16 | 				cout << i << endl;
17 | 				flag = 1;
18 | 				break;
19 | 			}
20 | 		}
21 | 		if (flag == 0) {
22 | 			cout << -1 << endl;
23 | 		}
24 | 	}
25 | }
26 | int main() {
27 | 	func();
28 | 	return 0;
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/代码/9.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<algorithm>
 4 | #include<string>
 5 | using namespace std;
 6 | 
 7 | struct student {
 8 | 	string num;
 9 | 	string name;
10 | 	string sex;
11 | 	int age;
12 | };
13 | 
14 | bool cmp(student s1, student s2) {
15 | 	return s1.num < s2.num;
16 | }
17 | 
18 | void func() {
19 | 	int n;
20 | 	cin >> n;
21 | 	vector<student> a(n);
22 | 	for (int i = 0;i < n;i++) {
23 | 		cin >> a[i].num >> a[i].name >> a[i].sex >> a[i].age;
24 | 	}
25 | 	sort(a.begin(), a.end(), cmp);
26 | 	int m;
27 | 	cin >> m;
28 | 	string find_num;
29 | 	for (int i = 0;i < m;i++) {
30 | 		cin >> find_num;
31 | 		int hi = n - 1;
32 | 		int lo = 0;
33 | 		int mid = (hi + lo) / 2;
34 | 		int flag = 0;
35 | 		while (hi >= lo) {
36 | 			if (a[mid].num < find_num) {
37 | 				lo = mid + 1;
38 | 				mid = (hi + lo) / 2;
39 | 			}
40 | 			else if (a[mid].num > find_num) {
41 | 				hi = mid - 1;
42 | 				mid = (hi + lo) / 2;
43 | 			}
44 | 			else {
45 | 				flag = 1;
46 | 				cout << a[mid].num << " " << a[mid].name << " " << a[mid].sex << " " << a[mid].age << endl;
47 | 				break; 
48 | 			}
49 | 		}
50 | 		if (flag == 0) {
51 | 			cout << "No Answer!" << endl;
52 | 		}
53 | 	}
54 | }
55 | int main() {
56 | 	func();
57 | 	return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/代码/代码列表.txt:
--------------------------------------------------------------------------------
 1 | 1.cpp 成绩排序
 2 | 2.cpp 日期差值
 3 | 3.cpp 周几计算
 4 | 4.cpp 统计同成绩学生人数
 5 | 5-1.cpp 排序解决输出m个最大数
 6 | 5-2.cpp hash解决输出m个最大数
 7 | 5-3.cpp 示例代码
 8 | 6.cpp 输出梯形
 9 | 7.cpp 叠筐
10 | 8.cpp 找x
11 | 9.cpp 查找学生信息
12 | 10.cpp FatMouse' Trade
13 | 11.cpp  今年暑假不 AC
14 | 数据结构
15 | 12.cpp 括号匹配问题
16 | 13.cpp 简单计算器
17 | 14.cpp 表达式求值
18 | 15.cpp 哈夫曼树
19 | 16.cpp 搬水果
20 | 17.cpp 二叉树遍历
21 | 18.cpp 二叉排序树
22 | 19.cpp 二叉搜索树
23 | 20.cpp 特殊乘法
24 | 	1：数学方法
25 | 	2:字符串方法
26 | 21.cpp 又一版 A+B
27 | 22.cpp 数制转换
28 | 23.cpp 最大公约数
29 | 24.cpp 最小公倍数
30 | 25.cpp 素数判定
31 | 26.cpp 素数筛选
32 | 27.cpp 质因数的个数
33 | 28.cpp 整除问题
34 | 29.cpp 人见人爱 A ^ B
35 | 30.cpp	 a+b
36 | 31.cpp	N 的阶层
37 | 32.cpp 进制转换
38 | 33.cpp 畅通工程
39 | 34.cpp more is better
40 | 35.cpp 又是畅通工程
41 | 35-1.cpp 又是畅通工程（改进版） 使用数组
42 | 36.cpp Freckles
43 | 37.cpp  最短路 floyd实现
44 | 37-1.cpp dijistra实现
45 | 38.cpp 最短路径问题
46 | 39.cpp Legal or Not
47 | 40.cpp  N阶楼梯上楼问题 
48 | 41.cpp 不容易系列之一
49 | 42.cpp  拦截导弹 
50 | 43.cpp  Coincidence
51 | 44.cpp 搬寝室
52 | 45.cpp greedy tino
53 | 45-1.cpp pdf中的代码
54 | 46.cpp POJ 2186 Popular Cows 
55 | 47.cpp 采药
56 | 48.cpp Piggy-Bank
57 | 49.cpp 珍惜现在，感恩生活
58 | 50.cpp 百鸡问题
59 | 51.cpp 胜利大逃亡
60 | 52.cpp 非常可乐
61 | 53.cpp 汉诺塔 III 数组实现
62 | 53-1.cpp 递归实现
63 | 54.cpp  Prime ring problem
64 | 55.cpp   Oil Deposit
65 | 56.cpp  Temple of the bone
66 | 57.cpp 字符串的查找删除
67 | 58.cpp 产生冠军


--------------------------------------------------------------------------------
/代码/王道考研机试指南.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/1020xyr/CodeSet/647679639a32ed6b439be76cdccd8c7b73b907a5/代码/王道考研机试指南.pdf


--------------------------------------------------------------------------------
/代码/笔记 .md:
--------------------------------------------------------------------------------
   1 | # 以前
   2 | 
   3 | 复杂度分析
   4 | 大多数上机题给予我们的程序1秒的运行时限，这也是最常见的时间限制数量级。
   5 | 对于该时限，通常，我们所设计的算法复杂度不能超过百万级别，即不能超过一千万。
   6 | 即若算法的时间复杂度是O(n^2)，则该n（往往在题目中会给出数据范围）不应大于3000，
   7 | 否则将会达到我们所说的千万数量级复杂度，从而程序运行时间超出题目中给出的用时限定。
   8 | 举例来说，我们不能在 1秒时限的题目当中对10000个整数进行冒泡排序，而必须使用快速
   9 | 排序等时间复杂度为 O(nlogn)的排序算法，否则程序很可能将会得到运行时间超
  10 | 出限制的评判结果。因此你可以对你的程序在最坏情况下的复杂度进行一个估
  11 | 算，假如确定其在百万数量级之内，那么你的程序一般是不会超出时间限制的。
  12 | 对于其它时间限制的情况，可以参考 1 秒时限对时间复杂度的要求，做出一定的
  13 | 估计，从而保证自己的程序运行所需的时间不会超过题目中对运行时间的限制。
  14 | 
  15 | ```c+++
  16 | scanf ("%4d%2d%2d",&y1,&m1,&d1) YYYYMMDD格式数据输入
  17 | ```
  18 | 
  19 | 预处理
  20 | 
  21 | 二维数组的初始化可以按行分段赋值，也可按行连续赋值。
  22 | 
  23 | ```c++
  24 | 数组 a[5][3]，按行分段赋值应该写作：
  25 | int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };
  26 | 按行连续赋值应该写作：
  27 | int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};
  28 | ```
  29 | 
  30 | 
  31 | 全局变量的使用 
  32 | char NameofWeek[7][20] =
  33 | {
  34 | 	"Sunday",
  35 | 	"Monday",
  36 | 	"Tuesday",
  37 | 	"Wednesday",
  38 | 	"Thursday",
  39 | 	"Friday",
  40 | 	"Saturday"
  41 | };
  42 | 
  43 | cin>>n;
  44 | while(n!=0){
  45 | 	cin>>n;
  46 | } 
  47 | 改成
  48 | while(cin>>n){
  49 | 	if(n==0) break;
  50 | }
  51 | 
  52 | ```c++
  53 | while (scanf ("%d",&n) != EOF && n != 0)
  54 | while (cin>>n && n != 0)
  55 | ```
  56 | 
  57 | 在oj中
  58 | 时间超时
  59 | cin cout 改成 scanf printf
  60 | 
  61 | 表示错误
  62 | 空格与换行符的输出是否错误
  63 | 
  64 | 0 1变换
  65 | (flag + 1) % 2
  66 | 
  67 | 格式输出
  68 | bool firstline = true;
  69 | if (firstline == true) {
  70 | 	firstline = false;
  71 | }
  72 | else {
  73 | 	cout << endl;
  74 | }
  75 | 
  76 | c++中string类可以使用> <比较字符串
  77 | 
  78 | 类型总是向下兼容的，有时候double替换int数据更加方便
  79 | 
  80 | 使用
  81 | vector<show> a(100);
  82 | sort(a.begin(), a.begin() + n);
  83 | 的方式节省空间
  84 | 贪心算法中贪心策略的选择 
  85 | 开始时间 结束时间 持续时间
  86 | 
  87 | 堆栈存入数组下标间接实现数组元素的操作
  88 | 
  89 | # 规范
  90 | 
  91 | ### 二叉排序树
  92 | 
  93 | 二叉排序树的标准插入操作
  94 | 
  95 | 插入以Node*代替void
  96 | 
  97 | ```c++
  98 | Node* addNode(Node* p,int val){
  99 | 	if(p==NULL){
 100 | 		p = new Node();
 101 | 		p->val = val;
 102 | 		return p;
 103 | 	}
 104 | 	if(p->val>val){
 105 | 		p->lchild = addNode(p->lchild,val);
 106 | 	}
 107 | 	else{
 108 | 		p->rchild = addNode(p->rchild,val);
 109 | 	}
 110 | 	return p;
 111 | }
 112 | ```
 113 | 
 114 | ### 二叉搜索树
 115 | 
 116 | 在选择的两种遍历方式中必须要包括中序遍历。如在数据结构中所讲 的，只有**包括中序的两种遍历**顺序才能唯一的确定一棵二叉树
 117 | 
 118 | 删除二叉树的原理非常简单，即删除该结点后，其中序遍历依然保持关键字 
 119 | 
 120 | 递增的顺序，只要符合这个条件，不同于上述规则的删除也是可行的
 121 | 
 122 | ### 大数加法
 123 | 
 124 | 
 125 | 
 126 | ```c++
 127 | string add(string a, string b,int radix ) {
 128 | 	reverse(a.begin(), a.end());
 129 | 	reverse(b.begin(), b.end());
 130 | 	int len_a = a.length();
 131 | 	int len_b = b.length();
 132 | 	a += string((50 - len_a) ,'0');
 133 | 	b += string((50 - len_b), '0');
 134 | 	int flag = 0;
 135 | 	for (int i = 0;i < 50;i++) {
 136 | 		int sum = a[i] + b[i] - '0' - '0' + flag;
 137 | 		flag = 0;
 138 | 		if (sum >= radix) {
 139 | 			sum = sum - radix;
 140 | 			flag = 1;
 141 | 		}
 142 | 		a[i] = sum + '0';
 143 | 	}
 144 | 	int len = len_a > len_b ? len_a : len_b;
 145 | 	while (a[len] != '0') {
 146 | 		len++;
 147 | 	}
 148 | 	string ans = a.substr(0, len);
 149 | 	reverse(ans.begin(), ans.end());
 150 | 	return ans;
 151 | }
 152 | ```
 153 | 
 154 | 
 155 | 
 156 | ### 进制转换
 157 | 
 158 | 
 159 | 
 160 | ```c++
 161 | string IntToX(int num, int radix) {
 162 | 	string res = "";
 163 | 	do {
 164 | 		int t = num % radix;
 165 | 		if (t <= 9 && t >= 0) {
 166 | 			res += t + '0';
 167 | 		}
 168 | 		else {
 169 | 			res += t - 10 + 'a';
 170 | 		}
 171 | 		num = num / radix;
 172 | 	} while (num != 0);
 173 | 	reverse(res.begin(), res.end());
 174 | 	return res;
 175 | }
 176 | ```
 177 | 
 178 | 
 179 | 
 180 | ```c++
 181 | #define ll long long
 182 | using namespace std;
 183 | 
 184 | ll XToInt(string num, int radix) {
 185 | 	ll ans = 0;
 186 | 	int len = num.length();
 187 | 	for (int i = 0;i < len;i++) {
 188 | 		if (num[i] >= '0' && num[i] <= '9') {
 189 | 			ans = ans * radix + num[i] - '0';
 190 | 		}
 191 | 		else {
 192 | 			ans = ans * radix + num[i] +10 - 'A';
 193 | 		}
 194 | 	}
 195 | 	return ans;
 196 | }
 197 | string IntToX(ll num, int radix) {
 198 | 	string res = "";
 199 | 	do{
 200 | 		int t = num % radix;
 201 | 		if (t >= 0 && t <= 9) {
 202 | 			res += t + '0';
 203 | 		}
 204 | 		else {
 205 | 			res += t + 'A' - 10;
 206 | 		}
 207 | 		num = num / radix; 
 208 | 	} while (num != 0);
 209 | 	reverse(res.begin(), res.end());
 210 | 	return res;
 211 | }
 212 | void func() {
 213 | 	int a, b;
 214 | 	string n;
 215 | 	cin >> a >> n >> b;
 216 | 	ll num = XToInt(n, a);
 217 | 	string ans = IntToX(num, b);
 218 | 	cout << ans << endl;
 219 | }
 220 | ```
 221 | 
 222 | 
 223 | 
 224 | ### long long
 225 | 
 226 |  数据类型long long 
 227 | 
 228 | 范围为-2^63 ~2^63-1。 (int  2^31-1 ) 2147483647 ~ -2147483648
 229 | 
 230 |  我们采用long long来表示两个int数的和 
 231 | 
 232 |  转义字符%lld 
 233 | 
 234 | ```c++
 235 | #define ll long long
 236 | ```
 237 | 
 238 | 
 239 | 
 240 | ### string 方法
 241 | 
 242 |   ```c++
 243 |  string s4 (5, 's');
 244 |   ```
 245 | 
 246 | 
 247 | 
 248 | ```c++
 249 | string((50 - len_b), '0')
 250 | ```
 251 | 
 252 | 
 253 | 
 254 | ```c++
 255 | string substr (size_t pos = 0, size_t len = npos) const;
 256 | ```
 257 | 
 258 | ### 最大公约数
 259 | 
 260 | 
 261 | 
 262 | ```c++
 263 | #include<iostream>
 264 | 
 265 | using namespace std;
 266 | 
 267 | int gcd(int a, int b) {
 268 | 	if (b == 0) return a;
 269 | 	return gcd(b, a % b);
 270 | }
 271 | void func() {
 272 | 	int a, b;
 273 | 	while (cin >> a >> b) {
 274 | 		int ans = gcd(a, b);
 275 | 		cout << ans << endl;
 276 | 	}
 277 | }
 278 | 
 279 | int main() {
 280 | 	func();
 281 | 	return 0;
 282 | }
 283 | ```
 284 | 
 285 | ### 最小公倍数
 286 | 
 287 | 
 288 | 
 289 | ```c++
 290 | #include<iostream>
 291 | using namespace std; 
 292 | int gcd(int a, int b) {
 293 | 	if (b == 0) return a;
 294 | 	return gcd(b, a % b);
 295 | }
 296 | 
 297 | void func() {
 298 | 	int a, b;
 299 | 	while (cin >> a >> b) {
 300 | 		int max = gcd(a, b);
 301 | 		int res = a / max * b;
 302 | 		cout << res << endl;
 303 | 	}
 304 | }
 305 | int main() {
 306 | 	func();
 307 | 	return 0;
 308 | }
 309 | 
 310 | ```
 311 | 
 312 | ### 素数
 313 | 
 314 | 
 315 | 
 316 | ```c++
 317 | bool IsPrime(int n) {
 318 | 	if (n <= 1) return false;
 319 | 	int len = sqrt(n);
 320 | 	for (int i = 2;i <= len;i++) {
 321 | 		if (n % i == 0) {
 322 | 			return false;
 323 | 		}
 324 | 	}
 325 | 	return true;
 326 | }
 327 | ```
 328 | 
 329 | ### 素数筛选法
 330 | 
 331 | 
 332 | 
 333 | ```c++
 334 | void func(int n) {
 335 | 	if (n < 12) {
 336 | 		cout << -1 << endl;
 337 | 		return;
 338 | 	}
 339 | 	vector<int> tmp(n, 0);
 340 | 	for (int i = 2;i < n;i++) {
 341 | 		if (tmp[i] == 0) {
 342 | 			for (int j = i * i;j < n;j=j+i) {
 343 | 				tmp[j] = 1;
 344 | 			}
 345 | 			if (i % 10 == 1) {
 346 | 				cout << i << " ";
 347 | 			}
 348 | 		}
 349 | 	}
 350 | 	cout << endl;
 351 | }
 352 | ```
 353 | 
 354 | 
 355 | 
 356 | ### 质因数个数
 357 | 
 358 | 数据预处理 质因数的巧妙处理
 359 | 
 360 | #### 10^9 -> 10^5
 361 | 
 362 | ```c++
 363 | #include<iostream>
 364 | #include<vector>
 365 | 
 366 | using namespace std;
 367 | vector<int> tmp(1000001, 0);
 368 | int len = 1000000;
 369 | void precess() {
 370 | 	int n = len;
 371 | 	for (int i = 2;i <=n ;i++) {
 372 | 		if (tmp[i] == 0) {
 373 | 			for (int j = i * i;j <= n;j = j + i) {
 374 | 				tmp[j] = 1;
 375 | 			}
 376 | 		}
 377 | 	}
 378 | }
 379 | void func(int n) {
 380 | 	int ans = 0;
 381 | 	int min = n > len ? len : n;
 382 | 	for (int i = 2;i <= min;i++) {
 383 | 		if (tmp[i] == 0) {
 384 | 			while (n % i == 0) {
 385 | 				ans++;
 386 | 				n = n / i;
 387 | 			}
 388 | 		}
 389 | 	}
 390 | 	if (n != 1) {				//如果仍未除尽，则只存在一个质因数
 391 | 		ans++;
 392 | 	}
 393 | 	cout << ans << endl;
 394 | }
 395 | 
 396 | int main() {
 397 | 	int n;
 398 | 	while (cin >> n) {
 399 | 		func(n);
 400 | 	}
 401 | 	return 0;
 402 | }
 403 | 
 404 | ```
 405 | 
 406 | 
 407 | 
 408 | ###  整除问题 
 409 | 
 410 | #### 非常巧妙的解题思路
 411 | 
 412 | ```c++
 413 | int getNum(int n, int p) {
 414 | 	int ans = 0;
 415 | 	for (int i = p;i <= n;i = i * p) {
 416 | 		ans += n / i;
 417 | 	}
 418 | 	return ans;
 419 | }
 420 | ```
 421 | 
 422 | 
 423 | 
 424 | ### 人见人爱 A ^ B
 425 | 
 426 | 二分法求幂，非常精简的算法
 427 | 
 428 | ```c++
 429 | #include<iostream>
 430 | 
 431 | using namespace std;
 432 | 
 433 | void func() {
 434 | 	int a, b;
 435 | 	while (cin >> a >> b) {
 436 | 		if (a == 0 && b == 0) break;
 437 | 		int ans = 1;
 438 | 		while (b != 0) {
 439 | 			if (b % 2 == 1) {
 440 | 				ans *= a;
 441 | 				ans = ans % 1000;  // 消去取余的两行则变成了正常的求幂的过程
 442 | 			}
 443 | 			b = b / 2;
 444 | 			a *= a;
 445 | 			a = a % 1000;
 446 | 		}
 447 | 		cout << ans << endl;
 448 | 	}
 449 | }
 450 | int main() {
 451 | 	func();
 452 | 	return 0;
 453 | }
 454 | 
 455 | ```
 456 | 
 457 | ### a+b
 458 | 
 459 | 使用string保存大整数，而不是int数组，但适用范围仅限于大数相加
 460 | 
 461 | ```c++\
 462 | string add(string a, string b) {
 463 | 	reverse(a.begin(), a.end());
 464 | 	reverse(b.begin(), b.end());
 465 | 	int len_a = a.length();
 466 | 	int len_b = b.length();
 467 | 	a += string(10010 - len_a, '0');
 468 | 	b += string(10010 - len_b, '0');
 469 | 	int max = len_a > len_b ? len_a : len_b;
 470 | 	max += 2;
 471 | 	int flag = 0;
 472 | 	for (int i = 0;i < max;i++) {
 473 | 		int sum = a[i] - '0' + b[i] - '0' + flag;
 474 | 		flag = 0;
 475 | 		if (sum >= 10) {
 476 | 			sum -= 10;
 477 | 			flag = 1;
 478 | 		}
 479 | 		a[i] = sum + '0';
 480 | 	}
 481 | 	int len = max - 2;
 482 | 	while (a[len] != '0') {
 483 | 		len++;
 484 | 	}
 485 | 	string ans = a.substr(0, len);
 486 | 	reverse(ans.begin(), ans.end());
 487 | 	return ans;
 488 | 
 489 | }
 490 | ```
 491 | 
 492 | 使用字符串数组取余
 493 | 
 494 | 大数对小数取余
 495 | 
 496 | ```c++
 497 | int ans = 0; //其中高精度大整数由高位至低位保存在字符数组str中,小整数保存在mod
 498 | 中
 499 | fo (int i = 0;str[i];i ++) { 
 500 |  	ans *= 10; 
 501 |     ans += str[i] - '0'; 
 502 |     ans %= mod; 
 503 | } 
 504 | printf("%d\n",ans); //ans即为计算后剩下的余数
 505 | ```
 506 | 
 507 | 
 508 | 
 509 | ### N 的阶层
 510 | 
 511 | 用int数组存储的big int的结构体
 512 | 
 513 | **bigdigit s;**
 514 | 
 515 | ```c++
 516 | struct bigdigit {
 517 | 	int digit[1000];
 518 | 	int size;
 519 | 	bigdigit() {
 520 | 		for (int i = 0;i < 1000;i++) {
 521 | 			digit[i] = 0;
 522 | 		}
 523 | 		size = 0;
 524 | 	}
 525 | 	void set(int x) {
 526 | 		do {
 527 | 			int t = x % 1000;
 528 | 			digit[size] = t;
 529 | 			size++;
 530 | 			x = x / 1000;
 531 | 		} while (x != 0);
 532 | 	}
 533 | 	void output() {
 534 | 		for (int i = size - 1;i >= 0;i--) {
 535 | 			if (i == size - 1) {
 536 | 				printf("%d", digit[i]);
 537 | 			}
 538 | 			else {
 539 | 				printf("%03d", digit[i]);
 540 | 			}
 541 | 		}
 542 | 		cout << endl;
 543 | 	}
 544 | };
 545 | 
 546 | ```
 547 | 
 548 | 
 549 | 
 550 | ### 进制转换
 551 | 
 552 | bigInteger 的实现 数组的一位存0-999的数字
 553 | 
 554 | ```c++
 555 | struct bigInteger {
 556 | 	int digit[1000];
 557 | 	int size;
 558 | 	bigInteger() {
 559 | 		for (int i = 0;i < 1000;i++) {
 560 | 			digit[i] = 0;
 561 | 		}
 562 | 		size = 0;
 563 | 	}
 564 | 	void set(int x) {			//设定初始值
 565 | 		do {
 566 | 			int t = x % 1000;
 567 | 			digit[size] = t;
 568 | 			size++;
 569 | 			x = x / 1000;
 570 | 		} while (x != 0);
 571 | 	}
 572 | 	void output() {				// 输出bigInteger
 573 | 		for (int i = size - 1;i >= 0;i--) {
 574 | 			if (i == size - 1) {
 575 | 				printf("%d", digit[i]);
 576 | 			}
 577 | 			else {
 578 | 				printf("%3d", digit[i]);
 579 | 			}
 580 | 		}
 581 | 		printf("\n");
 582 | 	}
 583 | 	bigInteger operator * (int x)const {	
 584 | 		bigInteger res;
 585 | 		int carry = 0;						// 进位
 586 | 		for (int i = 0;i < size;i++) {
 587 | 			int tmp = x * digit[i] + carry;
 588 | 			carry = tmp / 1000;
 589 | 			tmp = tmp % 1000;
 590 | 			res.digit[res.size] = tmp;
 591 | 			res.size++;
 592 | 		}
 593 | 		while (carry != 0) {
 594 | 			int t = carry % 1000;
 595 | 			carry = carry / 1000;
 596 | 			res.digit[res.size] = t;
 597 | 			res.size++;
 598 | 		}
 599 | 		return res;
 600 | 	}
 601 | 	bigInteger operator / (int x)const {
 602 | 		bigInteger res;
 603 | 		int remainer = 0;							// 余数
 604 | 		for (int i = size - 1;i >= 0;i--) {
 605 | 			int sum = remainer * 1000 + digit[i];
 606 | 			remainer = sum % x;
 607 | 			res.digit[i] = sum / x;
 608 | 		}
 609 | 		for (int i = 0;i < size ;i++) {				// 找到最后一位不为0的位置
 610 | 			if (res.digit[i] != 0) {
 611 | 				res.size = i;
 612 | 			}
 613 | 		}
 614 | 		res.size++;									// 最后的数字位置+1格
 615 | 		return res;
 616 | 	}
 617 | 	int operator %(int x) const {
 618 | 		int remainer = 0;
 619 | 		for (int i = size - 1;i >= 0;i--) {
 620 | 			remainer = (remainer * 1000 + digit[i]) % x;
 621 | 		}
 622 | 		return remainer;
 623 | 	}
 624 | 	bigInteger operator +(const bigInteger& A) const {
 625 | 		bigInteger res;
 626 | 		int carry = 0;								 // 进位
 627 | 		int max = size > A.size ? size : A.size;
 628 | 		for (int i = 0;i < max;i++) {
 629 | 			int sum = digit[i] + A.digit[i] + carry;
 630 | 			carry = sum / 1000;
 631 | 			res.digit[res.size] = sum % 1000;
 632 | 			res.size++;
 633 | 		}
 634 | 		if (carry != 0) {
 635 | 			res.digit[res.size] = carry;
 636 | 			res.size++;
 637 | 		}
 638 | 		return res;
 639 | 	}
 640 | };
 641 | ```
 642 | 
 643 | 
 644 | 
 645 | vector作为类成员的初始化
 646 | 
 647 | ```c++
 648 | class Foo(){
 649 | private:
 650 |     vector<string> name = vector<string>(5);
 651 |     vector<int> val{vector<int>(5,0)};
 652 | }
 653 | 
 654 | ```
 655 | 
 656 | 
 657 | 
 658 | ### 畅通工程
 659 | 
 660 | 并查集的实现类
 661 | 
 662 | 可以用int数组代替vector<int>
 663 | 
 664 | size用来记录连通分量的个数
 665 | 
 666 | ```c++
 667 | struct union_find {
 668 | 	vector<int> tree;
 669 | 	int size;
 670 | 	union_find(int n) {
 671 | 		tree = vector<int>(n+1);
 672 | 		for (int i = 1;i <= n;i++) {
 673 | 			tree[i] = i;
 674 | 		}
 675 | 		size = n;
 676 | 	}
 677 | 	int findRoot(int p) {
 678 | 		if (tree[p] == p) {
 679 | 			return p;
 680 | 		}
 681 | 		else {
 682 | 			int tmp = findRoot(tree[p]);
 683 | 			tree[p] = tmp;
 684 | 			return tmp;
 685 | 		}
 686 | 	}
 687 | 	bool isConnection(int p, int q) {
 688 | 		int pRoot = findRoot(p);
 689 | 		int qRoot = findRoot(q);
 690 | 		return (pRoot == qRoot);
 691 | 	}
 692 | 	void unions(int p, int q) {
 693 | 		int pRoot = findRoot(p);
 694 | 		int qRoot = findRoot(q);
 695 | 		if (pRoot != qRoot) {
 696 | 			tree[pRoot] = qRoot;
 697 | 			size--;
 698 | 		}
 699 | 	}
 700 | };
 701 | ```
 702 | 
 703 | ### more is better
 704 | 
 705 | 使用类实现
 706 | 
 707 | vector 可用数组代替 （内存更小？）
 708 | 
 709 | 可以用两个数组代替数组结构体
 710 | 
 711 | **相同的下标代表其关系**
 712 | 
 713 | 
 714 | 
 715 | ```c++
 716 | struct node {
 717 | 	int index;
 718 | 	int number;
 719 | };
 720 | struct union_find {
 721 | 	vector<node> tree;	
 722 | 	int size;								// 连通分量的个数
 723 | 	int maxNum;								// 最大的连通分量包含节点数
 724 | 	union_find(int n) {
 725 | 		tree = vector<node>(n + 1);
 726 | 		for (int i = 1;i <= n;i++) {
 727 | 			tree[i].index = i;
 728 | 			tree[i].number = 1;
 729 | 		}
 730 | 		size = n;
 731 | 		maxNum = 1;
 732 | 	}
 733 | 	void init(int n) {
 734 | 		tree = vector<node>(n + 1);
 735 | 		for (int i = 1;i <= n;i++) {
 736 | 			tree[i].index = i;
 737 | 			tree[i].number = 1;
 738 | 		}
 739 | 		size = n;
 740 | 		maxNum = 1;
 741 | 	}
 742 | 	int findRoot(int p) {
 743 | 		if (tree[p].index == p) {
 744 | 			return p;
 745 | 		}
 746 | 		else {
 747 | 			int tmp = findRoot(tree[p].index);
 748 | 			tree[p].index = tmp;
 749 | 			return tmp;
 750 | 		}
 751 | 	}
 752 | 	bool isConnection(int p, int q) {
 753 | 		int pRoot = findRoot(p);
 754 | 		int qRoot = findRoot(q);
 755 | 		return (pRoot == qRoot);
 756 | 	}
 757 | 	void unions(int p, int q) {
 758 | 		int pRoot = findRoot(p);
 759 | 		int qRoot = findRoot(q);
 760 | 		if (pRoot != qRoot) {
 761 | 			tree[pRoot].index = qRoot;
 762 | 			tree[qRoot].number += tree[pRoot].number;
 763 | 			size--;
 764 | 			maxNum = maxNum > tree[qRoot].number ? maxNum : tree[qRoot].number;
 765 | 		}
 766 | 	}
 767 | };
 768 | ```
 769 | 
 770 | 使用全局数组和函数代替类实现
 771 | 
 772 | ```c++
 773 | const int N = 10000001;
 774 | using namespace std;
 775 | int tree[N];
 776 | int sum[N];
 777 | int Max;
 778 | int findRoot(int p) {
 779 | 	if (tree[p] == p) {
 780 | 		return p;
 781 | 	}
 782 | 	else {
 783 | 		int tmp = findRoot(tree[p]);
 784 | 		tree[p] = tmp;
 785 | 		return tmp;
 786 | 	}
 787 | }
 788 | void unions(int p, int q) {
 789 | 	int pRoot = findRoot(p);
 790 | 	int qRoot = findRoot(q);
 791 | 	if (pRoot != qRoot) {
 792 | 		tree[pRoot] = qRoot;
 793 | 		sum[qRoot] += sum[pRoot];
 794 | 		Max = Max > sum[qRoot] ? Max : sum[qRoot];
 795 | 	}
 796 | }
 797 | 
 798 | ```
 799 | 
 800 | 
 801 | 
 802 | ### 又是畅通工程
 803 | 
 804 | 
 805 | 
 806 | **使用vector**
 807 | 
 808 | ```c++
 809 | struct node {
 810 | 	int p, q;
 811 | 	int weight;
 812 | 	node(int p1, int q1, int w1) {
 813 | 		p = p1;
 814 | 		q = q1;
 815 | 		weight = w1;
 816 | 	}
 817 | 	node(){
 818 | 		p = 0;
 819 | 		q = 0;
 820 | 		weight =0;
 821 | 	}
 822 | };
 823 | 
 824 | bool compare(node n1, node n2) {				// 比较函数
 825 | 	return n1.weight < n2.weight;
 826 | }
 827 | 
 828 | vector<node> tmp(len);
 829 | for (int i = 0;i < len;i++) {			// 接受输入，得到边-权重数组
 830 |     int p, q, weight;
 831 |     cin >> p >> q >> weight;
 832 |     tmp[i] = node(p, q, weight);
 833 | }
 834 | sort(tmp.begin(), tmp.end(), compare);	// 按权重从小到大排序
 835 | ```
 836 | 
 837 | **使用数组**
 838 | 
 839 | ```c++
 840 | struct Edge { 							//边结构体
 841 | 	int a, b; 							//边两个顶点的编号
 842 | 	int cost; 							//该边的权值
 843 | 	bool operator < (const Edge& A) const { //重载小于号使其可以按照边权从小到
 844 | 		大排列
 845 | 			return cost < A.cost;
 846 | 	}
 847 | }edge[6000];
 848 | 
 849 | for (int i = 1;i <= n * (n - 1) / 2;i ++) { 
 850 |  scanf ("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].cost); 
 851 |  } //输入
 852 |  sort(edge + 1,edge + 1 + n * (n - 1) / 2); //按照边权值递增排列所有的
 853 | 边
 854 | ```
 855 | 
 856 | 改进版
 857 | 
 858 | ```c++
 859 | #include<iostream>
 860 | #include<algorithm>
 861 | 
 862 | using namespace std;
 863 | 
 864 | struct Edge { 
 865 | 	int a, b;									//边两个顶点的编号
 866 | 	int cost;									//该边的权值
 867 | }edge[6000];
 868 | 
 869 | int village[120];
 870 | int sum;										// 生成树权重之和
 871 | int findRoot(int p) {							// 找到根节点
 872 | 	if (village[p] == p) {
 873 | 		return p;
 874 | 	}
 875 | 	else {
 876 | 		int tmp = findRoot(village[p]);
 877 | 		village[p] = tmp;
 878 | 		return tmp;
 879 | 	}
 880 | }
 881 | 
 882 | void unions(Edge e) {							// 连接节点
 883 | 	int pRoot = findRoot(e.a);
 884 | 	int qRoot = findRoot(e.b);
 885 | 	if (pRoot != qRoot) {
 886 | 		village[pRoot] = qRoot;
 887 | 		sum += e.cost;
 888 | 	}
 889 | }
 890 | bool compare(Edge e1, Edge e2) {				// 比较函数
 891 | 	return e1.cost < e2.cost;
 892 | }
 893 | 
 894 | void func() {
 895 | 	int n;
 896 | 	while (cin >> n && n != 0) {
 897 | 		int len = n * (n - 1) / 2;
 898 | 		for (int i = 0;i < len;i++) {			// 接受输入，得到边-权重数组
 899 | 			cin >>edge[i].a>> edge[i].b >> edge[i].cost;
 900 | 		}
 901 | 		sort(edge, edge  + len,compare);
 902 | 		sum = 0;
 903 | 		for (int i = 1;i <= n;i++) {			// 初始化
 904 | 			village[i] = i;
 905 | 		}
 906 | 		for (int i = 0;i < len;i++) {
 907 | 			unions(edge[i]);
 908 | 		}
 909 | 		cout << sum << endl;
 910 | 	}
 911 | }
 912 | int main() {
 913 | 	func();
 914 | 	return 0;
 915 | }
 916 | ```
 917 | 
 918 | ### Freckles
 919 | 
 920 | sqrt需要导入math.h
 921 | 
 922 | ```c++
 923 | struct Dot {
 924 | 	double x, y;
 925 | 	int index;
 926 | 	double getDistance(Dot d1) {
 927 | 		double ans = (d1.x - x) * (d1.x - x) + (d1.y - y) * (d1.y - y);
 928 | 		ans = sqrt(ans);
 929 | 		return ans;
 930 | 	}
 931 | }dot[120];
 932 | struct Edge {
 933 | 	int p, q;
 934 | 	double cost;
 935 | 
 936 | }edge[5200];
 937 | ```
 938 | 
 939 | 输出2位小数
 940 | 
 941 | ```c++
 942 | printf("%.2f",sum);
 943 | ```
 944 | 
 945 | 
 946 | 
 947 | 
 948 | 
 949 | ### 最短路
 950 | 
 951 | Floyd 算法: N<200&&全源最短路问题&&O（n3)
 952 | 
 953 | ```c++
 954 | #include<iostream>
 955 | 
 956 | using namespace std;
 957 | 
 958 | const int Max = 1000000;
 959 | 
 960 | int ans[120][120];
 961 | 
 962 | void func() {
 963 | 	int n, m;
 964 | 	while (cin >> n >> m) {
 965 | 		if (n == 0 && m == 0) {
 966 | 			break;
 967 | 		}
 968 | 		for (int i = 1;i <= n;i++) {
 969 | 			for (int j = 1;j <= n;j++) {
 970 | 				ans[i][j] = Max;
 971 | 			}
 972 | 		}
 973 | 		for (int i = 0;i < m;i++) {
 974 | 			int p, q, cost;
 975 | 			cin >> p >> q >> cost;
 976 | 			ans[p][q] = cost;
 977 | 			ans[q][p] = cost;
 978 | 		}
 979 | 		for (int k = 1;k <= n;k++) {
 980 | 			for (int i = 1;i <= n;i++) {
 981 | 				for (int j = 1;j <= n;j++) {
 982 | 					if (ans[i][k] + ans[k][j] < ans[i][j]) {
 983 | 						ans[i][j] = ans[i][k] + ans[k][j];
 984 | 					}
 985 | 				}
 986 | 			}
 987 | 		}
 988 | 		cout << ans[1][n] << endl;
 989 | 
 990 | 	}
 991 | }
 992 | 
 993 | int main() {
 994 | 	func();
 995 | 	return 0;
 996 | }
 997 | 
 998 | ```
 999 | 
1000 | 关键代码
1001 | 
1002 | ```c++
1003 | for (int k = 1;k <= n;k++) {
1004 | 			for (int i = 1;i <= n;i++) {
1005 | 				for (int j = 1;j <= n;j++) {
1006 | 					if (ans[i][k] + ans[k][j] < ans[i][j]) {
1007 | 						ans[i][j] = ans[i][k] + ans[k][j];
1008 | 					}
1009 | 				}
1010 | 			}
1011 | 		}
1012 | ```
1013 | 
1014 | 
1015 | 
1016 | dijistra实现
1017 | 
1018 | 单源路径问题&&O（n2）
1019 | 
1020 | ```c++
1021 | #include<iostream>
1022 | #include<vector>
1023 | 
1024 | using namespace std;
1025 | 
1026 | struct Edge {
1027 | 	int to;
1028 | 	int cost;
1029 | };
1030 | 
1031 | vector<Edge> edge[101];
1032 | bool marked[101];
1033 | int dist[101];
1034 | 
1035 | // 满足对于任意的k， dist[i]<=dist[k] + k到i的距离
1036 | void func() {
1037 | 	int n, m;
1038 | 	while (cin >> n >> m) {
1039 | 		if (m == 0 && n == 0) {
1040 | 			break;
1041 | 		}
1042 | 		for (int i = 1;i <= n;i++) {			// 初始化
1043 | 			marked[i] = false;
1044 | 			dist[i] = -1;
1045 | 			edge[i].clear();
1046 | 		}
1047 | 		for (int i = 0;i < m;i++) {				// 接受输入
1048 | 			int p, q, cost;
1049 | 			cin >> p >> q >> cost;
1050 | 			Edge tmp;
1051 | 			tmp.cost = cost;
1052 | 			tmp.to = q;
1053 | 			edge[p].push_back(tmp);
1054 | 			tmp.to = p;
1055 | 			edge[q].push_back(tmp);
1056 | 		}
1057 | 		marked[1] = true;
1058 | 		dist[1] = 0;
1059 | 
1060 | 		int v = 1;
1061 | 		for (int i = 0;i < n - 1;i++) {
1062 | 			for (int j = 0;j < edge[v].size();j++) {		// 刷新dist数组
1063 | 				int to = edge[v][j].to;
1064 | 				int cost = edge[v][j].cost;
1065 | 				if (marked[to]) continue;
1066 | 				int newDist = dist[v] + cost;
1067 | 				if (dist[to] == -1 || newDist < dist[to]) {
1068 | 					dist[to] = newDist;
1069 | 				}
1070 | 			}
1071 | 
1072 | 			int min = 100000000;
1073 | 			for (int j = 1;j <= n;j++) {					// 选择dist数组最小的值（未标记）
1074 | 				if (marked[j] || dist[j] == -1) continue;
1075 | 				if (min > dist[j]) {
1076 | 					min = dist[j];
1077 | 					v = j;
1078 | 				}
1079 | 			}
1080 | 			marked[v] = true;
1081 | 		}
1082 | 		cout << dist[n] << endl;
1083 | 	}
1084 | }
1085 | 
1086 | int main() {
1087 | 	func();
1088 | 	return 0;
1089 | }
1090 | ```
1091 | 
1092 | 
1093 | 
1094 | 
1095 | 
1096 | ### 最短路径问题
1097 | 
1098 | 其中最短路径算法中权重是一个抽象的集合，可以有多个数构成
1099 | 
1100 | 如果提交超时，可以尝试用scanf prinf 替换 cin cout
1101 | 
1102 | ```c++
1103 | #include<stdio.h>
1104 | #include<vector>
1105 | 
1106 | using namespace std;
1107 | 
1108 | struct Edge {
1109 | 	int to;
1110 | 	int cost;
1111 | 	int len;
1112 | };
1113 | int dist[1001];
1114 | int cost[1001];
1115 | bool marked[1001];
1116 | vector<Edge> edge[1000];
1117 | 
1118 | void func() {
1119 | 	int n, m;
1120 | 	while (scanf("%d %d",&n,&m)) {
1121 | 		if (n == 0 && m == 0) {
1122 | 			break;
1123 | 		}
1124 | 		for (int i = 1;i <= n;i++) {
1125 | 			dist[i] = -1;
1126 | 			marked[i] = false;
1127 | 			edge[i].clear();
1128 | 		}
1129 | 		for (int i = 0;i < m;i++) {
1130 | 			int a, b, d, p;
1131 | 			scanf("%d %d %d %d", &a, &b, &d, &p);
1132 | 			Edge tmp;
1133 | 			tmp.cost = p;
1134 | 			tmp.len = d;
1135 | 			tmp.to = a;
1136 | 			edge[b].push_back(tmp);
1137 | 			tmp.to = b;
1138 | 			edge[a].push_back(tmp);
1139 | 		}
1140 | 		int s, t;
1141 | 		scanf("%d %d", &s, &t);
1142 | 		int  v = s;
1143 | 
1144 | 		marked[v] = true;
1145 | 		dist[v] = 0;
1146 | 		cost[v] = 0;
1147 | 		for (int i = 0;i < n - 1;i++) {
1148 | 			for (int j = 0;j < edge[v].size();j++) {
1149 | 				int to = edge[v][j].to;
1150 | 				int newLen = dist[v] + edge[v][j].len;
1151 | 				int newCost = cost[v] + edge[v][j].cost;
1152 | 				if (marked[to]) continue;
1153 | 				if (dist[to] == -1 || newLen <dist[to] || (dist[to] == newLen && newCost < cost[to])) {
1154 | 					dist[to] = newLen;
1155 | 					cost[to] = newCost;
1156 | 				}
1157 | 			}
1158 | 			int minLen=100000000;
1159 | 			int minCost= 100000000;
1160 | 			for (int j = 1;j <= n;j++) {
1161 | 				if (marked[j] || dist[j] == -1) continue;
1162 | 				if (dist[j] < minLen || (dist[j] == minLen && cost[j] < minCost)) {
1163 | 					minLen = dist[j];
1164 | 					minCost = cost[j];
1165 | 					v = j;
1166 | 				}
1167 | 			}
1168 | 			marked[v] = true;
1169 | 			if (v == t) {
1170 | 				break;
1171 | 			}
1172 | 		}
1173 | 		printf("%d %d\n", dist[t], cost[t]);
1174 | 	}
1175 | }
1176 | int main() {
1177 | 	func();
1178 | 	return 0;
1179 | }
1180 | 
1181 | ```
1182 | 
1183 | ### Legal or Not
1184 | 
1185 | queue常用方法
1186 | 
1187 | ```c++
1188 | queue<int> Q;
1189 | Q.empty();
1190 | Q.pop();
1191 | Q.push();
1192 | Q.front();
1193 | ```
1194 | 
1195 | 
1196 | 
1197 | ```c++
1198 | #include<iostream>
1199 | #include<vector>
1200 | #include<queue>
1201 | 
1202 | using namespace std;
1203 | 
1204 | vector<int> edge[101];
1205 | int indegree[101];
1206 | queue<int> Q;
1207 | void func() {
1208 | 	int n, m;
1209 | 	while (cin >> n >> m && n != 0) {
1210 | 		while (!Q.empty()) {
1211 | 			Q.pop();
1212 | 		}
1213 | 		for (int i = 0;i < n;i++) {
1214 | 			indegree[i] = 0;
1215 | 			edge[i].clear();
1216 | 		}
1217 | 		for (int i = 0;i < m;i++) {
1218 | 			int x, y;
1219 | 			cin >> x >> y;
1220 | 			edge[x].push_back(y);
1221 | 			indegree[y]++;
1222 | 		}
1223 | 		for (int i = 0;i < n;i++) {
1224 | 			if (indegree[i] == 0) {
1225 | 				Q.push(i);
1226 | 			}
1227 | 		}
1228 | 		int size = 0;
1229 | 		while (!Q.empty()) {
1230 | 			int v = Q.front();
1231 | 			Q.pop();
1232 | 			size++;
1233 | 			for (int i = 0;i < edge[v].size();i++) {
1234 | 				int to = edge[v][i];
1235 | 				indegree[to]--;
1236 | 				if (indegree[to] == 0) {
1237 | 					Q.push(to);
1238 | 				}
1239 | 			}
1240 | 		}
1241 | 		if (size == n) {
1242 | 			cout << "YES" << endl;
1243 | 		}
1244 | 		else {
1245 | 			cout << "NO" << endl;
1246 | 		}
1247 | 	}
1248 | }
1249 | int main() {
1250 | 	func();
1251 | 	return 0;
1252 | }
1253 | ```
1254 | 
1255 | ### acm
1256 | 
1257 | set的使用，便于统计相异元素的个数
1258 | 
1259 | ```c++
1260 | set<string> AnsSet;
1261 | AnsSet.insert(s[res[0]]);
1262 | AnsSet.size() 
1263 | for (set<string>::iterator it = AnsSet.begin();it != AnsSet.end();++it) {
1264 | 	cout << *it << endl;
1265 | }
1266 | 
1267 | ```
1268 | 
1269 | 输入输出
1270 | 
1271 | > c中scanf函数读取换行符的问题
1272 | >
1273 | > c中利用scanf()函数输入字符串，在按下回车后'\n'字符是被存储在了缓存区的，如果下一次继续读入字符这个换行符可能会产生影响，也可能不会产生影响。总结如下：
1274 | >
1275 | > 不会产生影响的情况：第二次输入为“字符串”（或数字）；
1276 | >
1277 | > 会产生影响的情况：第二次读入的是‘字符’： 
1278 | >
1279 | > 因为读入的是字符，所以在第一个字符读完后的'\n', 在运行第二个scanf()时直接被读取了，所以第二个printf()函数输出为两个'\n';
1280 | >
1281 | > 如果想消除'\n'的影响可以在中间加个getchar()函数；
1282 | 
1283 |  https://blog.csdn.net/sinat_40043477/article/details/77748944 
1284 | 
1285 | 
1286 | 
1287 | cin cout加速
1288 | 
1289 | ```c++
1290 | ios::sync_with_stdio(false);
1291 | cin.tie(0);
1292 | 
1293 | ```
1294 | 
1295 |  https://blog.csdn.net/alex123980/article/details/51836550 
1296 | 
1297 | 
1298 | 
1299 | ###  N阶楼梯上楼问题 
1300 | 
1301 | 对于n=1的情况的处理
1302 | 
1303 | ```c++
1304 | #include<iostream>
1305 | #define ll long long
1306 | using namespace std;
1307 | void func() {
1308 | 	int n;
1309 | 	cin >> n;
1310 | 	ll f1 = 1;
1311 | 	ll f2 = 2;
1312 | 	int len = 3;
1313 | 	if (n <= 1) {
1314 | 		cout << 1 << endl;
1315 | 		return;
1316 | 	}
1317 | 	while (len <= n) {
1318 | 		ll tmp = f2;
1319 | 		f2 = f1 + f2;
1320 | 		f1 = tmp;
1321 | 		len++;
1322 | 	}
1323 | 	cout << f2 << endl;
1324 | }
1325 | int main() {
1326 | 	ios::sync_with_stdio(false);
1327 | 	cin.tie(0);
1328 | 	func();
1329 | }
1330 | 
1331 | 
1332 | ```
1333 | 
1334 | 
1335 | 
1336 | ### 不容易系列之一
1337 | 
1338 | 错排公式
1339 | 
1340 | F[n] = (n - 1) * F[n - 1] + (n - 1) * F[n - 2]
1341 | 
1342 | ```c++
1343 | #include<iostream>
1344 | #define ll long long
1345 | 
1346 | using namespace std;
1347 | 
1348 | ll f[21];
1349 | 
1350 | void process() {
1351 | 	f[1] = 0;
1352 | 	f[2] = 1;
1353 | 	for (int i = 3;i <= 20;i++) {
1354 | 		f[i] = (i - 1) * (f[i - 1] + f[i - 2]);
1355 | 	}
1356 | }
1357 | void func() {
1358 | 	process();
1359 | 	int n;
1360 | 	while (cin >> n) {
1361 | 		cout << f[n] << endl;
1362 | 	}
1363 | }
1364 | 
1365 | int main() {
1366 | 	ios::sync_with_stdio(false);
1367 | 	cin.tie(0);
1368 | 	func();
1369 | }
1370 | 
1371 | 
1372 | ```
1373 | 
1374 | ###  拦截导弹 
1375 | 
1376 | 最长递增子序列的递推公式为： 
1377 | 
1378 | ```c++
1379 | f[1] = 1;
1380 | f[n] = max(1, f[j] + 1 | j < i&& a[j] < a[i]);
1381 | 
1382 | ```
1383 | 
1384 | 
1385 | 
1386 | ```c++
1387 | #include<iostream>
1388 | 
1389 | using namespace std;
1390 | 
1391 | int f[30];
1392 | int a[30];
1393 | void func() {
1394 | 	int k;
1395 | 	while (cin >> k) {
1396 | 		for (int i = 1;i <= k;i++) {
1397 | 			cin >> a[i];
1398 | 		}
1399 | 		f[1] = 1;
1400 | 		for (int i = 2;i <= k;i++) {
1401 | 			int max = 1;
1402 | 			for (int j = 1;j < i;j++) {
1403 | 				if (a[j] >= a[i]) {
1404 | 					max = max > f[j] + 1 ? max : f[j] + 1;
1405 | 				}
1406 | 			}
1407 | 			f[i] = max;
1408 | 		}
1409 | 		int ans = 0;
1410 | 		for (int i = 1;i <= k;i++) {
1411 | 			ans = ans > f[i] ? ans : f[i];
1412 | 		}
1413 | 		cout << ans << endl;
1414 | 			
1415 | 	}
1416 | }
1417 | int main() {
1418 | 	ios::sync_with_stdio(false);
1419 | 	cin.tie(0);
1420 | 	func();
1421 | 	return 0;
1422 | }
1423 | 
1424 | ```
1425 | 
1426 | 
1427 | 
1428 | ###  Coincidence 
1429 | 
1430 | 字符串下标和dp数组下标的含义
1431 | 
1432 | dp[i] [j]表示 S1 中前 i 个字符与 S2 中前 j 个字符分别组成的两个前缀字符串的最 
1433 | 
1434 | 长公共子串长度。
1435 | 
1436 | ```c++
1437 | #include<iostream>
1438 | #include<string>
1439 | 
1440 | using namespace std;
1441 | int max(int a, int b) {
1442 | 	return (a > b ? a : b);
1443 | }
1444 | int dp[120][120];
1445 | 
1446 | void func() {
1447 | 	string a, b;
1448 | 	cin >> a >> b;
1449 | 	int len1 = a.length();
1450 | 	int len2 = b.length();
1451 | 	for (int i = 0;i < len1;i++) {
1452 | 		dp[i][0] = 0;
1453 | 	}
1454 | 	for (int i = 0;i < len2;i++) {
1455 | 		dp[0][i] = 0;
1456 | 	}
1457 | 	for (int i = 1;i<=len1;i++) {
1458 | 		for (int j = 1;j <= len2;j++) {
1459 | 			if (a[i-1] == b[j-1]) {
1460 | 				dp[i][j] = dp[i - 1][j - 1] + 1;
1461 | 			}
1462 | 			else {
1463 | 				dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
1464 | 			}
1465 | 		}
1466 | 	}
1467 | 	cout << dp[len1][len2] << endl;
1468 | }
1469 | 
1470 | int main() {
1471 | 	ios::sync_with_stdio(false);
1472 | 	cin.tie(0);
1473 | 	func();
1474 | 	return 0;
1475 | }
1476 | 
1477 | 
1478 | ```
1479 | 
1480 | 
1481 | 
1482 | ### 搬寝室 
1483 | 
1484 | 找到一个好的状态
1485 | 
1486 | ```c++
1487 | #include<iostream>
1488 | #include<algorithm>
1489 | using namespace std;
1490 | 
1491 | int dp[1020][2010];
1492 | int a[2010];
1493 | 
1494 | int min(int a, int b) {
1495 | 	return a < b ? a : b;
1496 | }
1497 | void process() {
1498 | 	for (int j = 0;j < 2010;j++) {
1499 | 		dp[0][j] = 0;
1500 | 	}
1501 | }
1502 | 
1503 | void func() {
1504 | 	int n, k;
1505 | 	process();
1506 | 	while (cin >> n >> k) {
1507 | 		for (int i = 1;i <= n;i++) {
1508 | 			cin >> a[i];
1509 | 		}
1510 | 		sort(a + 1, a + n + 1);
1511 | 		for (int i = 1;i <= k;i++) {
1512 | 			for (int j = 2 * i;j <= n;j++) {
1513 | 				int tmp = (a[j] - a[j - 1]) * (a[j] - a[j - 1]);
1514 | 				if (2 * i == j) {
1515 | 					dp[i][j] = dp[i - 1][j - 2]+ tmp;
1516 | 				}
1517 | 				else {
1518 | 					dp[i][j] = min(dp[i - 1][j - 2] + tmp, dp[i][j - 1]);
1519 | 				}
1520 | 			}
1521 | 		}
1522 | 		cout << dp[k][n] << endl;
1523 | 	}
1524 | }
1525 | int main() {
1526 | 	ios::sync_with_stdio(false);
1527 | 	cin.tie(0);
1528 | 	func();
1529 | 	return 0;
1530 | }
1531 | 
1532 | ```
1533 | 
1534 | 
1535 | 
1536 | ### POJ 2186 Popular Cows 
1537 | 
1538 | 
1539 | 
1540 |  https://blog.csdn.net/sr_19930829/article/details/39552991 
1541 | 
1542 | 
1543 | 
1544 | ### greedy tino
1545 | 
1546 | 动态规划，形而上学，不行退学
1547 | 
1548 | ```c++
1549 | 	for (int x = 1;x <= n;x++) {
1550 | 			for (int y = -2000;y <= 2000;y++) {
1551 | 				int tmp1 = -INF;
1552 | 				int tmp2 = -INF;
1553 | 				if (y - list[x] >= -2000 && dp[x - 1][y - list[x] + OFFSET] != -INF) 				 {
1554 | 					tmp1 = dp[x - 1][y - list[x] + OFFSET] + list[x];
1555 | 				}
1556 | 				if (y + list[x] <= 2000 && dp[x - 1][y + list[x] + OFFSET] != -INF) {
1557 | 					tmp2 = dp[x - 1][y + list[x] + OFFSET] + list[x];
1558 | 				}
1559 | 				if (tmp2 > tmp1) {
1560 | 					tmp1 = tmp2;
1561 | 				}
1562 | 				if (dp[x - 1][y + OFFSET] > tmp1) {
1563 | 					tmp1 = dp[x - 1][y + OFFSET];
1564 | 				}
1565 | 				dp[x][y + OFFSET] = tmp1;
1566 | 			}
1567 | 		}
1568 | 
1569 | ```
1570 | 
1571 | 
1572 | 
1573 | ### 采药
1574 | 
1575 | > 恰好达到临界值 dp[0] [0]等于0 dp[0] [i]为不存在或无穷
1576 | >
1577 | > 临界值之下 dp[0] [i] 均为0
1578 | >
1579 | > 最大值 dp[j] = max(dp[j], dp[j - times[i]] + value[i]);
1580 | >
1581 | > 最小值	dp[j] = min(dp[j], dp[j - times[i]] + value[i]);
1582 | >
1583 | > 在 0-1 背包中，之所以逆序循环更新状态是 
1584 | >
1585 | > 为了保证更新 dp[j]时，dp[j - list[i].w]的状态尚未因为本次更新而发生改变
1586 | 
1587 | ```c++
1588 | for (int i = 1;i <= M;i++) {
1589 |     for (int j = T;j>=times[i];j--) {
1590 |         dp[j] = max(dp[j], dp[j - times[i]] + value[i]);
1591 |     }
1592 | }
1593 | 
1594 | ```
1595 | 
1596 | 
1597 | 
1598 | ### Piggy-Bank
1599 | 
1600 | > 完全背包问题 顺序循环
1601 | >
1602 | > 0-1背包问题 逆序循环
1603 | 
1604 | ```c++
1605 | for (int i = 1;i <= sub;i++) {
1606 |     dp[i] = INF;
1607 | }
1608 | dp[0] = 0;
1609 | for (int i = 1;i <= N;i++) {
1610 |     for (int j = W[i]; j <= sub;j++) {
1611 |         if (dp[j - W[i]] != INF) {
1612 |             dp[j] = min(dp[j], dp[j - W[i]] + P[i]);
1613 |         }
1614 |     }
1615 | }
1616 | 
1617 | ```
1618 | 
1619 | 
1620 | 
1621 | ### 珍惜现在，感恩生活
1622 | 
1623 | > 多重背包：将个数分解为类似于二进制形式，然后使用0-1背包的方法计算
1624 | 
1625 | ```c++
1626 | for (int i = 1;i <= m;i++) {
1627 |     cin >> p >> h >> k;
1628 |     int c = 1;
1629 |     while (k - c > 0) {
1630 |         k -= c;
1631 |         P[++cnt] = c * p;
1632 |         H[cnt] = c * h;
1633 |         c *= 2;
1634 |     }
1635 |     P[++cnt] = k * p;
1636 |     H[cnt] = k * h;
1637 | }
1638 | for (int i = 0;i <= n;i++) {
1639 |     dp[i] = 0;
1640 | }
1641 | for (int i = 1;i <= cnt;i++) {
1642 |     for (int j = n;j >= P[i];j--) {
1643 |         dp[j] = max(dp[j], dp[j - P[i]] + H[i]);
1644 |     }
1645 | }
1646 | 
1647 | ```
1648 | 
1649 | 
1650 | 
1651 | ### 胜利大逃亡
1652 | 
1653 | 广度优先搜索的基本模式
1654 | 
1655 | 加入初始节点（状态）
1656 | 
1657 | 一直出队，对出队的节点进行判断是否结束
1658 | 
1659 | 而后进行状态扩展
1660 | 
1661 | ```c++
1662 | while (!Q.empty()) Q.pop();			// 清空队列
1663 | Q.push(state(0,0,0,0));
1664 | while (!Q.empty()) {
1665 |     state s = Q.front();
1666 |     int x, y, z, t;
1667 |     x = s.x;
1668 |     y = s.y;
1669 |     z = s.z;
1670 |     t = s.t;
1671 |     Q.pop();
1672 |     if (t > T) {			// 提前结束遍历
1673 |         cout << -1 << endl;
1674 |         break;
1675 |     }
1676 |     if (x == A - 1 && y == B - 1 && z == C - 1) {
1677 |         cout <<t << endl;
1678 |         break;
1679 |     }
1680 |     marked[x][y][z] = true;
1681 |     add(x+1, y, z, t);
1682 |     add(x-1, y, z, t);
1683 |     add(x, y+1, z, t);
1684 |     add(x, y-1, z, t);
1685 |     add(x, y, z+1, t);
1686 |     add(x, y, z-1, t);
1687 | }
1688 | 
1689 | ```
1690 | 
1691 | ### 非常可乐
1692 | 
1693 | 通过数组下标，减少相似的代码
1694 | 
1695 | ```
1696 | C语言中，在相同类型的变量间赋值时是直接内存复制的，即将他们的内存进行复制，而两个同类型的结构体变量属于同一种变量，所以赋值时是按照他们的内存分布来直接拷贝的。所以，在C语言中两个相同类型的结构体变量之间是可以相互赋值的。但是要注意指针的浅层复制问题。
1697 | 
1698 | ```
1699 | 
1700 | **本题可以用数论知识解决**
1701 | 
1702 | ```c++
1703 | #include<cstdio>
1704 | #include<iostream>
1705 | using namespace std;
1706 | int gcd(int a,int b)
1707 | {
1708 |     return b?gcd(b,a%b):a;
1709 | }
1710 | int main()
1711 | {
1712 |     int a,b,c;
1713 |     while(scanf("%d%d%d",&a,&b,&c),a+b+c)
1714 |     {
1715 |         a/=gcd(b,c);
1716 |         if(a&1)printf("NO\n");
1717 |         else printf("%d\n",a-1);
1718 |     }
1719 |     return 0;
1720 | }
1721 | 
1722 | ```
1723 | 
1724 | 
1725 | 
1726 | ```c++
1727 | struct state {
1728 | 	int capacity[3];									// 为了方便赋值 分别表示各种现有饮料量
1729 | 	int cnt;
1730 | 	state(int s1, int m1, int n1, int cnt1) {
1731 | 		capacity[0] = s1;
1732 | 		capacity[1] = m1;
1733 | 		capacity[2] = n1;
1734 | 		cnt = cnt1;
1735 | 	}
1736 | };
1737 | int go[][2] = {											// 从哪个瓶子倒入哪个瓶子
1738 | 	 0,1,
1739 | 	 0,2,
1740 | 	 1,0,
1741 | 	 1,2,
1742 | 	 2,0,
1743 | 	 2,1
1744 | };
1745 | const int maxn = 101;
1746 | bool marked[maxn][maxn][maxn];
1747 | queue<state> Q;
1748 | int S, M, N;
1749 | int MaxCapacity[3];										// 3个容器的最大容量
1750 | 
1751 | ```
1752 | 
1753 | 
1754 | 
1755 | ```c++
1756 | void add(int from, int to, state st) {
1757 | 	state st1 = st;										// 倒完之后的状态
1758 | 	if (st1.capacity[from] == 0) return;				// 如果前一个瓶子是空的
1759 | 	if (st1.capacity[to] == MaxCapacity[to]) return;	// 如果后一个瓶子是满的
1760 | 	int sum = st1.capacity[from] + st1.capacity[to];	
1761 | 		if (sum <= MaxCapacity[to]) {					// 前一个瓶全部倒入后一个瓶子
1762 | 			st1.capacity[to] = sum;
1763 | 			st1.capacity[from] = 0;
1764 | 		}
1765 | 		else {											// 倒满为止
1766 | 			st1.capacity[to] = MaxCapacity[to];
1767 | 			st1.capacity[from] = sum - MaxCapacity[to];
1768 | 		}
1769 | 		st1.cnt++;
1770 | 		int s = st1.capacity[0];
1771 | 		int m = st1.capacity[1];
1772 | 		int n = st1.capacity[2];
1773 | 		if (!marked[s][m][n]) {
1774 | 			marked[s][m][n] = true;
1775 | 			Q.push(st1);
1776 | 		}
1777 | }
1778 | 
1779 | ```
1780 | 
1781 | 
1782 | 
1783 | ### Prime ring problem
1784 | 
1785 | 遍历后回溯的方法
1786 | 
1787 | ```c++
1788 | for (int i = 2;i <= n;i++) {
1789 |     if (!marked[i]) {
1790 |         ans[num + 1] = i;
1791 |         marked[i] = true;
1792 |         DFS(num + 1);
1793 |         marked[i] = false;
1794 |     }
1795 | }
1796 | 
1797 | ```
1798 | 
1799 | ### Temple of the bone
1800 | 
1801 | 通过奇偶性进行剪枝操作
1802 | 
1803 | ```c++
1804 | if ((((x + y) % 2 + t % 2)) % 2 != (ex + ey) % 2) { // 剪枝操作2
1805 |     return;
1806 | }
1807 | 
1808 | ```
1809 | 
1810 | ### 字符串的查找删除
1811 | 
1812 | 字符串的大小写转换，查找，删除操作 以及 gets的使用
1813 | 
1814 | ```c++
1815 | #include<iostream>
1816 | #include<string>
1817 | #include<algorithm>
1818 | #include<cctype>
1819 | using namespace std;
1820 | 
1821 | void func() {
1822 | 	string tar,example,output;
1823 | 	cin >> tar;
1824 | 	transform(tar.begin(), tar.end(), tar.begin(), ::tolower);	// 转换为小写，注意::.明确命名空间
1825 | 	int len = tar.size();
1826 | 	char tmp[100];
1827 | 	while (gets(tmp)) {										    // 读取整行
1828 | 		example = tmp;											// example为全部小写的字符串，output为输入字符串
1829 | 		output = example;
1830 | 		transform(example.begin(), example.end(), example.begin(), ::tolower);
1831 | 		int index;
1832 | 		while ((index = example.find(tar)) != string::npos) {	// 如果可以找到
1833 | 			example.erase(index, len);
1834 | 			output.erase(index, len);
1835 | 		}
1836 | 		while ((index = example.find(' ')) != string::npos) {
1837 | 			example.erase(index, 1);
1838 | 			output.erase(index, 1);
1839 | 		}
1840 | 		cout << output << endl;
1841 | 	}
1842 | }
1843 | 
1844 | ```
1845 | 
1846 | > 当程序运行至gets语句后，它将 
1847 | >
1848 | > 依次读入遗留在输入缓冲中的数据直到出现换行符，并将除换行符外的所有已读 
1849 | >
1850 | > 字符保存在字符数组中，同时从输入缓冲中去除该换行符
1851 | >
1852 | > 
1853 | >
1854 | > 与其对应，scanf ("%s",str)函数读取输入缓冲的字符直到出现空格、 
1855 | >
1856 | > 换行字符，它将读到的字符保存至字符数组str中，但并不删除缓冲中紧接的空格 
1857 | >
1858 | > 与换行
1859 | 
1860 | ### 产生冠军
1861 | 
1862 | map的使用
1863 | 
1864 | ```c++
1865 | int in[2002];								// 可以直接理解成被打败的次数
1866 | map<string, int> M;
1867 | M.clear();
1868 | if (M.find(b) == M.end()) {
1869 |     M[b] = start;
1870 |     in[start]++;
1871 |     start++;
1872 | }
1873 | else {
1874 |     in[M[b]]++;
1875 | }
1876 | ```
1877 | 
1878 | ### 技巧
1879 | 
1880 | ```c++
1881 | // 滚动数组
1882 | int dp[2][M];
1883 | int *src; //源指针
1884 | int *des; //目的指针
1885 | src = dp[1]; 
1886 | des = dp[0];
1887 | for (int i = 1;i <= n;i ++) { 
1888 |     swap(src,des); //交换源和目的指针
1889 |     for (int j = 1;j <= m;j ++) { 
1890 |         des[j] = max(src[j + 1],src[j - 1]); 
1891 |     } 
1892 | }
1893 | // 位运算
1894 | if (a % 2 == 1)
1895 |     
1896 | if (a & 1 == 1)
1897 |     
1898 | a /= 2;
1899 | 
1900 | a >>= 1;
1901 | 
1902 | // 输入外挂
1903 | bool readint(int& ret) { //输入整数,并将整数保存在引用变量ret中
1904 | 	int sgn; //符号
1905 | 
1906 | 	char c; //字符
1907 | 
1908 | 	c = getchar(); //读入字符
1909 | 
1910 | 	if (c == EOF)return false; //若达到文件尾返回true
1911 | 
1912 | 	while (c != '-' && c < '0' || c>'9') c = getchar(); //跳过不为整数的部分
1913 | 
1914 | 	sgn = (c == '-') ? -1 : 1;  //若出现负号
1915 | 
1916 | 	ret = (c == '-') ? 0 : (c - '0');  //若未出现负号
1917 | 	while ((c = getchar()) >= '0' && c <= '9')ret = ret * 10 + (c - '0'); //计算连续几个字符
1918 | 	组成数字的数值
1919 | 	ret *= sgn; //乘上符号位
1920 | 	return true; //读入成功返回true 
1921 | }
1922 | ```
1923 | 
1924 | 


--------------------------------------------------------------------------------