二哥OJ 1051-1250

最新推荐文章于 2021-06-21 12:19:13 发布
最新推荐文章于 2021-06-21 12:19:13 发布
阅读量590 收藏 1
点赞数
分类专栏： OJ 文章标签： OJ oj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/biwendong/article/details/78701461
版权

1051

#include <iostream>
using namespace std;
 
class linkList
{
private:
	struct node
	{
		int data;
		node *next;
 
		node() :next(NULL) {}
		node(int n, node *p = NULL) :data(n), next(p) {}
	}*head, *last;
public:
	linkList() {
		head = last = new node;
	}
	~linkList()
	{
		while (head)
		{
			node *p = head->next;
			delete head;
			head = p;
		}
	}
	void insert(int n)
	{
		last = last->next = new node(n);
	}
	int find(int n)
	{
		node *p = head->next, *q=head;
		int i = 0;
		while (p)
		{
			++i;
			if (p->data == n) break;
			q = p;
			p = p->next;
		}
		if (p)
		{
			q->next = p->next;
			p->next = head->next;
			head->next = p;
		}
		return i;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	int num, m;
	linkList l;
	for (int i = 0;i < n;++i)
	{
		cin >> num;
		l.insert(num);
	}
	int result = 0;
	cin >> m;
	for (int i = 0;i < m;++i)
	{
		cin >> num;
		result += l.find(num);
	}
	cout << result << '\n';
	cin.get();
	cin.get();
	return 0;
}

1053

#include <iostream>
#include <algorithm>
using namespace std;
 
struct node
{
	int x, y, num;
	node(int xx, int yy, int n = 0) :x(xx), y(yy), num(n) {}
};
 
int x[100000];
int y[100000];
node *origin[10005] = { NULL };
 
bool cmp(node *p1, node *p2)
{
	return(p1->x < p2->x || p1->x == p2->x&&p1->y < p2->y);
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	for (int i = 0;i < 100000;++i)
		x[i] = y[i] = i;
	int n, m;
	cin >> n;
	int a, b, c, op;
	for (int i = 0;i < n;++i)
	{
		cin >> a >> b >> c;
		origin[i] = new node(a, b, c);
	}
	sort(origin, origin + n, cmp);
	cin >> m;
	for (int i = 0;i < m;++i)
	{
		cin >> op >> a >> b;
		switch (op)
		{
		case 0:
			if (a != b)
			{
				x[a] ^= x[b];
				x[b] ^= x[a];
				x[a] ^= x[b];
			}
			break;
		case 1:
			if (a != b)
			{
				y[a] ^= y[b];
				y[b] ^= y[a];
				y[a] ^= y[b];
			}
			break;
		case 2:
			a = x[a];
			b = y[b];
			int value = 0;
			int begin = 0, end = n - 1;
			while (begin <= end)
			{
				int mid = begin + end >> 1;
				if (origin[mid]->x < a || origin[mid]->x == a&&origin[mid]->y < b)begin = mid + 1;
				else if (origin[mid]->x > a || origin[mid]->x == a&&origin[mid]->y > b)end = mid - 1;
				else
				{
					value = origin[mid]->num;
					break;
				}
			}
			cout << value << '\n';
		}
	}
	cin.get();
	cin.get();
	for (int i = 0;i < n;++i)delete origin[i];
	return 0;
}

1054

#include <iostream>
using namespace std;
 
class SBT
{
private:
	struct node
	{
		int data, size;
		node *left, *right;
 
		node(int d, node *p = NULL, node *q = NULL) :data(d), size(1), left(p), right(q) {}
	}*root;
	int size(node *p)
	{
		return(p ? p->size : 0);
	}
	void makeEmpty(node *&t)
	{
		if (t)
		{
			makeEmpty(t->left);
			makeEmpty(t->right);
			delete t;
			t = NULL;
		}
	}
	void LL(node *&t)
	{
		node *t1 = t->left;
		t->left = t1->right;
		t1->right = t;
		t = t1;
		t->right->size = size(t->right->left) + size(t->right->right) + 1;
		t->size = size(t->left) + size(t->right) + 1;
	}
	void RR(node *&t)
	{
		node *t1 = t->right;
		t->right = t1->left;
		t1->left = t;
		t = t1;
		t->left->size = size(t->left->left) + size(t->left->right) + 1;
		t->size = size(t->left) + size(t->right) + 1;
	}
	void LR(node *&t)
	{
		RR(t->left);
		LL(t);
	}
	void RL(node *&t)
	{
		LL(t->right);
		RR(t);
	}
	void maintain(node *&t, bool flag)
	{
		if (flag)
		{
			if (t->right&&size(t->right->right) > size(t->left))
				RR(t);
			else if (t->right&&size(t->right->left) > size(t->left))
				RL(t);
			else return;
		}
		else if (t->left&&size(t->left->left) > size(t->right)) LL(t);
		else if (t->left&&size(t->left->right) > size(t->right))LR(t);
		else return;
		maintain(t->left, false);
		maintain(t->right, true);
		maintain(t, false);
		maintain(t, true);
	}
	void insert(node *&t, int x)
	{
		if (!t)
		{
			t = new node(x);
			return;
		}
		++t->size;
		if (x < t->data) insert(t->left, x);
		else insert(t->right, x);
		maintain(t, x >= t->data);
	}
	int remove(node *&t, int x)
	{
		if (!t)return 0;
		--t->size;
		if (x == t->data || !(t->left) && x<t->data || !(t->right) && x>t->data)
		{
			int del = t->data;
			if (t->left&&t->right)
				t->data = remove(t->left, x + 1);
			else t = (t->left ? t->left : t->right);
			return del;
		}
		else if (x < t->data) return remove(t->left, x);
		else return remove(t->right, x);
	}
	int findOrder(node *t, int x)
	{
		if (!t)return -1;
		if (size(t->left) == x - 1) return t->data;
		else if (size(t->left) < x) return findOrder(t->right, x - size(t->left) - 1);
		else return findOrder(t->left, x);
	}
public:
	SBT(node *t = NULL) :root(t) {}
	~SBT() { makeEmpty(root); }
	void insert(int x) { insert(root, x); }
	void remove(int x) { remove(root, x); }
	int size() { return size(root); }
	int findOrder(int x) { return findOrder(root, x); }
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, min;
	cin >> n >> min;
	char command;
	int k, leave = 0;
	int delta = 0;
	SBT t;
	for (int i = 0;i < n;++i)
	{
		cin >> command >> k;
		switch (command)
		{
		case 'I':
			if (k >= min) t.insert(k - delta);
			break;
		case 'A':
			delta += k;
			break;
		case 'S':
			delta -= k;
			int tmp;
			while (t.size() && ((tmp = t.findOrder(1)) + delta < min))
			{
				t.remove(tmp);
				++leave;
			}
			break;
		case 'F':
			int found = t.findOrder(t.size() - k + 1);
			cout << (found == -1 ? -1 : found + delta) << '\n';
		}
	}
	cout << leave << '\n';
	cin.get();
	cin.get();
	return 0;
}

#include <iostream>
using namespace std;
 
class SBT
{
private:
	struct node
	{
		int data, size;
		node *left, *right;
 
		node(int d, node *p = NULL, node *q = NULL) :data(d), size(1), left(p), right(q) {}
	}*root;
	int size(node *p)
	{
		return(p ? p->size : 0);
	}
	void makeEmpty(node *&t)
	{
		if (t)
		{
			makeEmpty(t->left);
			makeEmpty(t->right);
			delete t;
			t = NULL;
		}
	}
	void LL(node *&t)
	{
		node *t1 = t->left;
		t->left = t1->right;
		t1->right = t;
		t = t1;
		t->right->size = size(t->right->left) + size(t->right->right) + 1;
		t->size = size(t->left) + size(t->right) + 1;
	}
	void RR(node *&t)
	{
		node *t1 = t->right;
		t->right = t1->left;
		t1->left = t;
		t = t1;
		t->left->size = size(t->left->left) + size(t->left->right) + 1;
		t->size = size(t->left) + size(t->right) + 1;
	}
	void LR(node *&t)
	{
		RR(t->left);
		LL(t);
	}
	void RL(node *&t)
	{
		LL(t->right);
		RR(t);
	}
	void maintain(node *&t, bool flag)
	{
		if (flag)
		{
			if (t->right&&size(t->right->right) > size(t->left))
				RR(t);
			else if (t->right&&size(t->right->left) > size(t->left))
				RL(t);
			else return;
		}
		else if (t->left&&size(t->left->left) > size(t->right)) LL(t);
		else if (t->left&&size(t->left->right) > size(t->right))LR(t);
		else return;
		maintain(t->left, false);
		maintain(t->right, true);
		maintain(t, false);
		maintain(t, true);
	}
	void insert(node *&t, int x)
	{
		if (!t)
		{
			t = new node(x);
			return;
		}
		++t->size;
		if (x < t->data) insert(t->left, x);
		else insert(t->right, x);
		maintain(t, x >= t->data);
	}
	int remove(node *&t, int x)
	{
		if (!t)return 0;
		--t->size;
		int del;
		if (x == t->data || !(t->left) && x<t->data || !(t->right) && x>t->data)
		{
			del = t->data;
			if (t->left&&t->right)
			{
				t->data = remove(t->left, x + 1);
				maintain(t, true);
				return del;
			}
			else
			{
				node *tmp = t;
				t = (t->left ? t->left : t->right);
				delete tmp;
				return del;
			}
		}
		else if (x < t->data) del=remove(t->left, x);
		else del=remove(t->right, x);
		if(t)maintain(t, x < t->data);
		return del;
	}
	int findOrder(node *t, int x)
	{
		if (!t)return -1;
		if (size(t->left) == x - 1) return t->data;
		else if (size(t->left) < x) return findOrder(t->right, x - size(t->left) - 1);
		else return findOrder(t->left, x);
	}
public:
	SBT(node *t = NULL) :root(t) {}
	~SBT() { makeEmpty(root); }
	void insert(int x) { insert(root, x); }
	void remove(int x) { remove(root, x); }
	int size() { return size(root); }
	int findOrder(int x) { return findOrder(root, x); }
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, min;
	cin >> n >> min;
	char command;
	int k, leave = 0;
	int delta = 0;
	SBT t;
	for (int i = 0;i < n;++i)
	{
		cin >> command >> k;
		switch (command)
		{
		case 'I':
			if (k >= min) t.insert(k - delta);
			break;
		case 'A':
			delta += k;
			break;
		case 'S':
			delta -= k;
			int tmp;
			while (t.size() && ((tmp = t.findOrder(1)) + delta < min))
			{
				t.remove(tmp);
				++leave;
			}
			break;
		case 'F':
			int found = t.findOrder(t.size() - k + 1);
			cout << (found == -1 ? -1 : found + delta) << '\n';
		}
	}
	cout << leave << '\n';
	cin.get();
	cin.get();
	return 0;
}

1056

#include <iostream>
using namespace std;
 
int N;
int treeArr[500001] = { 0 };
 
void add(int x, int y)
{
	for (int i = x;i <= N;i += i&(-i))treeArr[i] += y;
}
 
int query(int x)
{
	int sum = 0;
	for (int i = x;i > 0;i -= i&(-i))sum += treeArr[i];
	return sum;
}
 
class DisjointSet
{
private:
	int size;
	int *parent;
	int cnt;
public:
	DisjointSet(int n) :size(n),cnt(n)
	{
		parent = new int[size+1];
		for (int i = 0;i < size;++i) parent[i + 1] = -1;
		parent[0] = 0;
		add(1, size);
	}
	~DisjointSet()
	{
		delete[]parent;
	}
	int find(int x)
	{
		if (parent[x] < 0)return x;
		else if (parent[x] == 0)return 0;
		else return parent[x] = find(parent[x]);
	}
	void merge(int root1, int root2)
	{
		if (root1 == root2)return;
		add(-parent[root1], -1);
		add(-parent[root2], -1);
		if (parent[root1] > parent[root2])
		{
			parent[root2] += parent[root1];
			parent[root1] = root2;
			add(-parent[root2], 1);
		}
		else
		{
			parent[root1] += parent[root2];
			parent[root2] = root1;
			add(-parent[root1], 1);
		}
		--cnt;
	}
	void eat(int root)
	{
		if(parent[root])
		{
			add(-parent[root], -1);
			parent[root] = 0;
		}
		--cnt;
	}
	int findK(int k)
	{
		if (cnt < k)return 0;
		k = cnt - k + 1;
		int l = 1, r = N;
		while (l <= r)
		{
			int mid = l + r >> 1;
			if (query(mid) < k)l = mid + 1;
			else r = mid - 1;
		}
		return l;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int M;
	cin >> N >> M;
	char command;
	int x, y;
	DisjointSet d(N);
	for (int i = 0;i < M;++i)
	{
		cin >> command;
		switch (command)
		{
		case 'C':
		{
			cin >> x >> y;
			int rt1 = d.find(x);
			int rt2 = d.find(y);
			if (rt1 != 0 && rt2 != 0 && rt1 != rt2) d.merge(rt1, rt2);
		}
			break;
		case 'D':
		{
			cin >> x;
			int rt = d.find(x);
			if (rt != 0)d.eat(rt);
		}
			break;
		case 'Q':
			cin >> x;
			cout << d.findK(x) << '\n';
			break;
		}
	}
	cin.get();
	cin.get();
	return 0;
}

1069

#include <iostream>
#include <cstring>
using namespace std;
 
bool dp[100005];
int que[100005];
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, m;
	cin >> n >> m;
	int value[100];
	int cnt;
	while (n != 0 || m != 0)
	{
		memset(dp, 0, sizeof(dp));
		memset(que, 0, sizeof(que));
		dp[0] = true;
		for (int i = 0;i < n;++i)cin >> value[i];
		for (int i = 0;i < n;++i)
		{
			cin >> cnt;
			if (m / value[i] < cnt) cnt = m / value[i];
			for (int j = 0;j < value[i];++j)
			{
				int sum = 0, front = 0, back = -1;//sum为前面几位的计数，若大于0，说明该状态可以达到。
				for (int k = j;k <= m;k += value[i])
				{
					if (back - front == cnt) sum -= que[front++];//背包问题中，数量的限制。
					que[++back] = dp[k];
					sum += dp[k];
					if (sum) dp[k] = true;
				}
			}
		}
		int ans = 0;
		for (int i = 1;i <= m;++i)
		{
			if (dp[i]) ++ans;
		}
		cout << ans << '\n';
		cin >> n >> m;
	}
	return 0;
}

1073

#include <iostream>
using namespace std;
 
int main()
{
	int n, dat[201], dp[201][201] = { 0 }, ans = 0;
	cin >> n;
	for (int i = 1;i <= n;i++) {
		cin >> dat[i];
		dat[i + n] = dat[i];
	}
	for (int i = 2;i<n + n;i++) //顺序的安排。
		for (int j = i - 1;j >= 1 && i - j < n;j--) 
		{
			for (int k = j;k < i;k++) 
			{
				int tmp = dp[j][k] + dp[k + 1][i] + dat[j] * dat[k + 1] * dat[i + 1];//上面顺序的安排保证了此处所用的dp已经计算过了。
				if (tmp > dp[j][i]) dp[j][i] = tmp;
			}
			if (dp[j][i] > ans) ans = dp[j][i];
		}
	cout << ans << endl;
	cin.get();
	cin.get();
	return 0;
}

1077

#include <iostream>
using namespace std;
 
long long s[31][31] = { 0 };
int root[31][31];
 
long long state(int i, int j)
{
	if (s[i][j]) return s[i][j];
	if (i > j)return s[i][j] = 1;
	s[i][j] = 1 << 63;
	for (int k = i;k <= j;++k)
	{
		long long tmp = state(i, k - 1)*state(k + 1, j) + s[k][k];
		if (tmp > s[i][j])
		{
			s[i][j] = tmp;
			root[i][j] = k;
		}
	}
	return s[i][j];
}
 
void preOrder(int l, int r)
{
	if (l <= r)
	{
		cout << root[l][r] << ' ';
		preOrder(l, root[l][r] - 1);
		preOrder(root[l][r] + 1, r);
	}
}
 
int main()
{
	int n;
	cin >> n;
	for (int i = 1;i <= n;++i)
	{
		cin >> s[i][i];
		root[i][i] = i;
	}
	cout << state(1, n) << '\n';
	preOrder(1, n);
	cout << endl;
	cin.get();
	cin.get();
	return 0;
}

1106

#include <iostream>
using namespace std;
 
bool block[10][3][3], row[10][9], col[10][9];
 
bool isOk(int n, int i, int j)
{
	return (block[n][i / 3][j / 3] && row[n][i] && col[n][j]);
}
 
int ansNum(int arr[][9], int i, int j)
{
	int count = 0;
	if (i == 9) return 1;//终止条件。
	if (arr[i][j] == 0)//为0才填入。
	{
		for (int n = 1;n <= 9;++n)
		{
			if (isOk(n, i, j))
			{
				block[n][i / 3][j / 3] = row[n][i] = col[n][j] = false;
				switch (ansNum(arr, i + (j + 1) / 9, (j + 1) % 9))
				{
				case 1:
					++count;
					if (count > 1) return 2;
					break;
				case 2:
					return 2;
				}
				block[n][i / 3][j / 3] = row[n][i] = col[n][j] = true;//回溯。
			}
		}
		return count;
	}
	else return ansNum(arr, i + (j + 1) / 9, (j + 1) % 9);
}
 
bool initBool(int arr[][9])
{
	int count = 0;
	for (int n = 1;n <= 9;++n)
	{
		int i, j;
		for (i = 0;i < 3;++i)
			for (j = 0;j < 3;++j)
				block[n][i][j] = true;
		for (i = 0;i < 9;++i) row[n][i] = col[n][i] = true;
		for (i = 0;i<9;++i)
			for (j = 0;j<9;++j)
				if (arr[i][j] == n)
				{
					++count;
					if (!block[n][i / 3][j / 3] || !row[n][i] || !col[n][j]) return false;//检查初始数据是否违规。
					block[n][i / 3][j / 3] = row[n][i] = col[n][j] = false;
				}
	}
	return (count >= 17);//至少17个已知数据。
}
 
int main()
{
	int T;
	cin >> T;
	int sudoku[9][9] = { 0 };
	for (int i = 0;i < T;++i)
	{
		for (int j = 0;j < 9;++j)
			for (int k = 0;k < 9;++k) cin >> sudoku[j][k];
		if (!initBool(sudoku)) cout << "No" << endl;
		else cout << (ansNum(sudoku, 0, 0)==1 ? "Yes" : "No") << endl;
	}
	cin.get();
	cin.get();
	return 0;
}

1107

#include <iostream>
using namespace std;
 
int main()
{
	int m, n;
	cin >> m;
	for (int i = 0;i < m;++i)
	{
		cin >> n;
		cout << (n == 0 ? "no" : "yes") << endl;
	}
	cin.get();
	cin.get();
	return 0;
}

1111

#include <iostream>
#include <cstring>
using namespace std;
 
char pre[27], mid[27];
char treeData[1001] = "";
 
void buildTree(char *pstart, char *mstart,int len,int pos)
{
	if (len > 0)
	{
		treeData[pos] = *pstart;
		int i;
		for (i = 0;i < len;++i)
		{
			if (mstart[i] == *pstart)break;
		}
		buildTree(pstart + 1, mstart, i, pos * 2);
		buildTree(pstart + 1 + i, mstart + i + 1, len - i - 1, pos * 2 + 1);
	}
}
 
int main()
{
	cin >> pre >> mid;
	int n = strlen(pre);
	buildTree(pre, mid, n, 1);
	int cnt = 0;
	for (int i = 1;i <= 1000;++i)
	{
		if (treeData[i] != '\0')
		{
			cout << treeData[i];
			++cnt;
		}
		else cout << "NULL";
		cout << ' ';
		if (cnt == n)break;
	}
	cout << '\n';
	cin.get();
	cin.get();
	return 0;
}

1202

#include <iostream>
#include <string>
using namespace std;
 
class bigInt
{
	friend bigInt operator+(const bigInt& num1, const bigInt& num2);
	friend ostream& operator<<(ostream &os, const bigInt& num);
private:
	struct node
	{
		int data;
		node *next;
 
		node(int val, node *p = NULL) :data(val), next(p) {}
	}*head;
 
public:
	bigInt():head(NULL){}
	bigInt(const char *str);
	bigInt(const bigInt& num);
	~bigInt()
	{
		node *tmp;
		while (head != NULL)
		{
			tmp = head;
			head = head->next;
			delete tmp;
		}
	}
};
 
bigInt::bigInt(const char* str)
{
	head = NULL;
	for (int i = 0;str[i] != '\0';++i)
		head = new node(str[i] - '0', head);
}
bigInt::bigInt(const bigInt& num)
{
	if (num.head == NULL)
	{
		head = NULL;
		return;
	}
	node *p = num.head->next, *q;
	q=head = new node(num.head->data);
	while (p != NULL)
	{
		q=q->next = new node(p->data);
		p = p->next;
	}
}
bigInt operator+(const bigInt& num1, const bigInt& num2)
{
	bigInt tmp;
	if (num1.head == NULL || num2.head == NULL)return tmp;
	tmp.head = new bigInt::node((num1.head->data + num2.head->data) % 10);
	int carry = (num1.head->data + num2.head->data) / 10;
	bigInt::node *p = num1.head->next, *q = num2.head->next,*end=tmp.head;
	while (p != NULL&&q != NULL)
	{
		end = end->next = new bigInt::node((p->data + q->data + carry) % 10);
		carry = (p->data + q->data + carry) / 10;
		p = p->next;
		q = q->next;
	}
	if (q != NULL) p = q;
	while (p != NULL)
	{
		end = end->next = new bigInt::node((p->data + carry) % 10);
		carry = (p->data + carry) / 10;
		p = p->next;
	}
	if (carry == 1)end->next = new bigInt::node(1);
	return tmp;
}
ostream& operator<<(ostream &os, const bigInt& num)
{
	string str="";
	bigInt::node *p = num.head;
	while (p != NULL)
	{
		str = char(p->data + '0') + str;
		p = p->next;
	}
	os << str;
	return os;
}
 
 
 
int main()
{
	string str1, str2;
	cin >> str1 >> str2;
	bigInt num1(str1.c_str()), num2(str2.c_str());
	bigInt num(num1 + num2);
	cout << num << endl;
	cin.get();
	cin.get();
	return 0;
}

1203

#include <iostream>
#include <cstring>
using namespace std;
 
template <class elemType>
class vector;
 
template <class elemType>
vector<elemType> operator+(const vector<elemType>& v1, const vector<elemType>& v2);
template <class elemType>
ostream & operator<<(ostream &os, const vector<elemType>&v);
 
template <class elemType>
class vector
{
	friend vector<elemType> operator+ <>(const vector<elemType>& v1, const vector<elemType>& v2);
	friend ostream &operator<< <>(ostream &os, const vector<elemType>&v);
private:
	elemType *data;
	int length, maxSize;
	
	void doubleSpace();
 
public:
	vector(int size = 10) :length(0), maxSize(size) { data = new elemType[maxSize]; }
	vector(const vector<elemType>& v);
	~vector() { delete[]data; }
	vector<elemType>& operator=(const vector<elemType>& v);
	void push(const elemType& x);
};
 
template <class elemType>
void vector<elemType>::doubleSpace()
{
	elemType *tmp = data;
	maxSize *= 2;
	data = new elemType[maxSize];
	for (int i = 0;i < length;++i)data[i] = tmp[i];
	delete[]tmp;
}
 
template <class elemType>
vector<elemType>::vector(const vector<elemType>& v):length(v.length),maxSize(v.maxSize)
{
	data = new elemType[maxSize];
	for (int i = 0;i < length;++i)
	{
		data[i] = v.data[i];
	}
}
 
template <class elemType>
vector<elemType>& vector<elemType>::operator=(const vector<elemType>& v)
{
	if (this == &v)return *this;
	delete[]data;
	length = v.length;
	maxSize = v.maxSize;
	data = new elemType[maxSize];
	for (int i = 0;i < length;++i)
		data[i] = v.data[i];
	return *this;
}
 
template <class elemType>
void vector<elemType>::push(const elemType& x)
{
	if (length == maxSize)doubleSpace();
	data[length++] = x;
}
 
template <class elemType>
vector<elemType> operator+(const vector<elemType>&v1, const vector<elemType>& v2)
{
	vector<elemType> tmp;
	tmp.length = v1.length + v2.length;
	tmp.maxSize = v1.maxSize + v2.maxSize;
	delete[]tmp.data;
	tmp.data = new elemType[tmp.maxSize];
	int i;
	for (i = 0;i < v1.length;++i)
		tmp.data[i] = v1.data[i];
	for (;i < tmp.length;++i)
		tmp.data[i] = v2.data[i - v1.length];
	return tmp;
}
 
template <class elemType>
ostream& operator<<(ostream &os, const vector<elemType>&v)
{
	for (int i = 0;i < v.length;++i)
		os << v.data[i] << ' ';
	os << endl;
	return os;
}
 
template <class T>
void link(int n, int m)
{
	T tmp;
	vector<T> v1, v2, v;
	for (int i = 0;i < n;++i)
	{
		cin >> tmp;
		v1.push(tmp);
	}
	for (int i = 0;i < m;++i)
	{
		cin >> tmp;
		v2.push(tmp);
	}
	v = v1 + v2;
	cout << v;
}
 
int main()
{
	char str[7];
	cin >> str;
	int n, m;
	cin >> n >> m;
	if (strcmp(str, "int") == 0)
		link<int>(n, m);
	else if (strcmp(str, "char") == 0)
		link<char>(n, m);
	else if (strcmp(str, "double") == 0)
		link<double>(n, m);
	cin.get();
	cin.get();
	return 0;
}

1204

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
using namespace std;
 
class error {};
 
class editor
{
private:
	struct node
	{
		string data;
		node *next;
 
		node():next(NULL) {}
		node(string str, node *p = NULL) :data(str), next(p) {}
	}*head;
 
	node* move(int n);
	const node* move(int n) const;
	void list(int n1, int n2) const;
	void ins(int i, int j,const char* str);
	void del(int i, int j, int num);
public:
	~editor()
	{
		node *p = head->next;
		while (p != NULL)
		{
			node *q = p;
			p = p->next;
			delete q;
		}
		delete head;
	}
	void input();
	void run();
};
 
void editor::input()
{
	head = new node;
	node *p=head;
	string str;
	getline(cin, str);
	while (str.length()!=6||strcmp(str.c_str(), "******") != 0)
	{
		p = p->next = new node(str);
		getline(cin, str);
	}
}
void editor::run()
{
	char command[5];
	cin >> command;
	while (strcmp(command, "quit") != 0)
	{
		if (strcmp(command, "list") == 0)
		{
			int n1, n2;
			cin >> n1 >> n2;
			list(n1, n2);
		}
		else if (strcmp(command, "ins") == 0)
		{
			int i, j;
			char str[101];
			cin >> i >> j;
			cin.get();
			cin.getline(str,101);
			ins(i, j, str);
		}
		else if (strcmp(command, "del") == 0)
		{
			int i, j, num;
			cin >> i >> j >> num;
			del(i, j, num);
		}
		cin >> command;
	}
	node *p = head->next;
	while (p != NULL)
	{
		cout << p->data << endl;
		p = p->next;
	}
}
editor::node * editor::move(int n)
{
	if (n <= 0)throw error();
	node *p = head;
	for (int i = 0;i < n;++i)
	{
		p = p->next;
		if (p == NULL) throw error();
	}
	return p;
}
const editor::node * editor::move(int n) const
{
	if (n <= 0)throw error();
	const node *p = head;
	for (int i = 0;i < n;++i)
	{
		p = p->next;
		if (p == NULL) throw error();
	}
	return p;
}
void editor::list(int n1, int n2) const
{
	const node *start, *end;
	try
	{
		if (n1 > n2)throw error();
		start = move(n1);
		end = move(n2);
		while (start != end)
		{
			cout << start->data << endl;
			start = start->next;
		}
		cout << end->data << endl;
	}
	catch (error) { cout << "Error!" << endl; }
}
void editor::ins(int i, int j, const char* str)
{
	node *p;
	try
	{
		p = move(i);
		if (j <= 0 || j > p->data.length() + 1) throw error();
		p->data.insert(j - 1, str);
	}
	catch (error) { cout << "Error!" << endl; }
}
void editor::del(int i, int j, int num)
{
	node *p;
	try
	{
		p = move(i);
		if (j <= 0 || j+num > p->data.length()+1)throw error();
		p->data.erase(j - 1, num);
	}
	catch (error) { cout << "Error!" << endl; }
}
 
int main()
{
	editor e;
	e.input();
	e.run();
	cin.get();
	cin.get();
	return 0;
}

1205

#include <iostream>
#include <stack>
using namespace std;
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	stack<int> v;
	int m, n;
	cin >> m >> n;
	v.push(m);
	v.push(n);
	while (true)
	{
		n = v.top();
		v.pop();
		if (v.empty()) { cout << n << endl;break; }
		m = v.top();
		v.pop();
		if (m == 0)v.push(n + 1);
		else if (n == 0)
		{
			v.push(m - 1);
			v.push(1);
		}
		else
		{
			v.push(m - 1);
			v.push(m);
			v.push(n - 1);
		}
	}
	return 0;
}

1206

#include <iostream>
#include <cstring>
using namespace std;
 
class stack
{
private:
	char *data;
	int topP;
	int maxSize;
 
	void doubleSpace()
	{
		char *tmp = data;
		data = new char[maxSize * 2];
		for (int i = 0;i < maxSize;++i)data[i] = tmp[i];
		maxSize *= 2;
		delete[] tmp;
	}
public:
	stack() :topP(-1), maxSize(10) { data = new char[maxSize]; }
	bool empty()
	{
		return topP == -1;
	}
	void push(char c)
	{
		if (topP == maxSize - 1)doubleSpace();
		data[++topP] = c;
	}
	char pop()
	{
		if(!empty()) return data[topP--];
	}
	char top()
	{
		if(!empty()) return data[topP];
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	stack v;
	char str[1000];
	bool isOk = true;
	while (cin >> str)
	{
		if (strcmp(str, "begin") == 0 || strcmp(str, "if") == 0)
			v.push(str[0]);
		else if (strcmp(str, "then") == 0)
		{
			if (v.empty() || v.pop()!='i') isOk = false;
			else v.push('t');
		}
		else if (strcmp(str, "end") == 0)
		{
			do
			{
				if (v.empty()||v.top()=='i')
				{
					isOk = false;break;
				}
				if (v.pop() == 'b')break;
			} while (true);
			if (!isOk)break;
		}
		else if (strcmp(str, "else") == 0)
		{
			if (v.empty() || v.pop()!='t') isOk = false;
		}
		if (!isOk) break;
	}
	while (isOk&&!v.empty())
	{
		if (v.pop() != 't')isOk = false;
	}
	if (isOk)cout << "Match!" << '\n';
	else cout << "Error!" << '\n' ;
	cin.get();
	cin.get();
	return 0;
}

1207

#include <iostream>
#include <iomanip>
using namespace std;
 
class queue
{
private:
	int *data;
	int front, back;
	int maxSize;
 
	void doubleSpace()
	{
		int *tmp = new int[maxSize * 2];
		for (int i = 1;i < maxSize;++i)
			tmp[i] = data[(front + i) % maxSize];
		front = 0;
		back = maxSize - 1;
		maxSize *= 2;
		delete[]data;
		data = tmp;
	}
public:
	queue(int initSize = 10) :maxSize(initSize),front(0),back(0) { data = new int[maxSize]; }
	~queue() { delete[]data; }
	void enQueue(int n)
	{
		if ((back + 1) % maxSize == front) doubleSpace();
		back = (back + 1) % maxSize;
		data[back] = n;
	}
	int deQueue()
	{
		front = (front + 1) % maxSize;
		return data[front];
	}
	int getHead()
	{
		return data[(front + 1) % maxSize];
	}
	bool isEmpty()
	{
		return front == back;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int N;
	cin >> N;
	queue q0, q1;
	int carType, arriveTime;
	int sum0 = 0, sum1 = 0;
	int cnt0=0, cnt1=0;
	int timer;
	for (int i = 0;i < N;++i)
	{
		cin >> carType >> arriveTime;
		if (carType == 0)
		{
			q0.enQueue(arriveTime);
			++cnt0;
		}
		else
		{
			q1.enQueue(arriveTime);
			++cnt1;
		}
	}
	for (timer = 0;!q0.isEmpty() || !q1.isEmpty();timer += 10)
	{
		int ship = 0;
		for (;ship < 8 && !q0.isEmpty() && q0.getHead() <= timer;++ship)
			sum0 += timer - q0.deQueue();
		for (;ship < 10 && !q1.isEmpty() && q1.getHead() <= timer;++ship)
			sum1 += timer - q1.deQueue();
		for (;ship < 10 && !q0.isEmpty() && q0.getHead() <= timer;++ship)
			sum0 += timer - q0.deQueue();
	}
	cout << setprecision(3)<<setiosflags(ios::fixed)<< double(sum0) / cnt0 << ' ' << double(sum1) / cnt1 << '\n';
	cin.get();
	cin.get();
	return 0;
}

1211

#include <iostream>
using namespace std;
 
struct node
{
	int num, lchild, rchild, father;
	node() :num(0), lchild(0), rchild(0), father(0) {}
};
 
class staticBTree
{
private:
	node *data;
	int size;
	int root;
public:
	staticBTree() :data(NULL), size(0),root(0) {}
	~staticBTree()
	{
		if (data != NULL) delete[]data;
	}
	void getRoot()
	{
		int i = 1;
		while (data[i].father != 0)
			i = data[i].father;
		root = i;
	}
	void createTree(int N)
	{
		size = N;
		data = new node[N + 1];
		int p, q;
		for (int i = 1;i <= N;++i)
		{
			cin >> p >> q;
			data[i].lchild = p;
			data[i].rchild = q;
			data[p].father = data[q].father = i;
		}
		getRoot();
	}
	bool isComplete()
	{
		int *que = new int[size];
		int head = 0;
		int back = 0;
		que[back++] = root;
		data[root].num = 1;
		int tmp;
		while (head != back)
		{
			tmp = que[head++];
			if (data[tmp].lchild != 0)
			{
				que[back] = data[tmp].lchild;
				data[que[back++]].num = data[tmp].num * 2;
			}
			if (data[tmp].rchild != 0)
			{
				que[back] = data[tmp].rchild;
				data[que[back++]].num = data[tmp].num * 2 + 1;
			}
		}
		delete[]que;
		return data[tmp].num == size;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int N;
	cin >> N;
	staticBTree bt;
	bt.createTree(N);
	cout << (bt.isComplete() ? 'Y' : 'N') << '\n';
	cin.get();
	cin.get();
	return 0;
}

1212

#include <iostream>
using namespace std;
 
struct node
{
	int lchild, rchild, father,v;
	node() :lchild(0), rchild(0), father(0),v(0) {}
};
 
class staticBTree
{
private:
	node *data;
	int size;
	int root;
public:
	staticBTree() :data(NULL), size(0),root(0) {}
	~staticBTree()
	{
		if (data != NULL) delete[]data;
	}
	void getRoot()
	{
		int i = 1;
		while (data[i].father != 0)
			i = data[i].father;
		root = i;
	}
	void createTree(int N)
	{
		size = N;
		data = new node[N + 1];
		int p, q, v;
		for (int i = 1;i <= N;++i)
		{
			cin >> p >> q >> v;
			data[i].lchild = p;
			data[i].rchild = q;
			data[i].v = v;
			data[p].father = data[q].father = i;
		}
		getRoot();
	}
	void levelTraverse()
	{
		int *que = new int[size];
		int head = 0;
		int back = 0;
		que[back++] = root;
		int tmp;
		while (head != back)
		{
			tmp = que[head++];
			cout << data[tmp].v << ' ';
			if (data[tmp].lchild != 0)
				que[back++] = data[tmp].lchild;
			if (data[tmp].rchild != 0)
				que[back++] = data[tmp].rchild;
		}
		cout << '\n';
		delete[]que;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int N;
	cin >> N;
	staticBTree bt;
	bt.createTree(N);
	bt.levelTraverse();
	cin.get();
	cin.get();
	return 0;
}

1213

#include <iostream>
using namespace std;
 
struct node
{
	int left, right, parent, value;
	
	node() :left(0), right(0), parent(0) {}
};
 
class binaryTree
{
	friend bool checkEqual(const binaryTree& t1, const binaryTree& t2, int tt1, int tt2)
	{
		if (tt1 == 0 && tt2 == 0)return true;
		else if (!(tt1&&tt2))return false;
		else if (t1.data[tt1].value == t2.data[tt2].value)
		{
			return checkEqual(t1, t2, t1.data[tt1].left, t2.data[tt2].left) && checkEqual(t1, t2, t1.data[tt1].right, t2.data[tt2].right);
		}
		else return false;
	}
	friend bool operator==(const binaryTree& t1, const binaryTree& t2)
	{
		if (t1.size != t2.size)return false;
		else return checkEqual(t1, t2, t1.root, t2.root);
	}
	
private:
	node *data;
	int root;
	int size;
 
	void getRoot()
	{
		root = 1;
		while (data[root].parent)root = data[root].parent;
	}
public:
	binaryTree(node arr[],int sz) :data(arr),size(sz)
	{
		getRoot();
	}
};
 
node t1[100005], t2[100005];
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, m;
	cin >> n;
	for (int i = 1;i <= n;++i)
	{
		cin >> t1[i].left >> t1[i].right >> t1[i].value;
		if (t1[i].left)t1[t1[i].left].parent = i;
		if (t1[i].right)t1[t1[i].right].parent = i;
	}
	cin >> m;
	for (int i = 1;i <= m;++i)
	{
		cin >> t2[i].left >> t2[i].right >> t2[i].value;
		if (t2[i].left)t2[t2[i].left].parent = i;
		if (t2[i].right)t2[t2[i].right].parent = i;
	}
	binaryTree bt1(t1, n), bt2(t2, m);
	cout << (bt1 == bt2 ? 'Y' : 'N') << '\n';
	cin.get();
	cin.get();
	return 0;
}

1214

#include <iostream>
#include <cstring>
using namespace std;
 
int que[100000];
 
struct node
{
	int lchild, nextBrother, father,v;
	node() :lchild(0), nextBrother(0), father(0),v(0) {}
};
 
class staticBTree
{
private:
	node *data;
	int size;
	int root;
 
	void preOrder(int n)
	{
		cout << data[n].v << ' ';
		n = data[n].lchild;
		while (n != 0)
		{
			preOrder(n);
			n = data[n].nextBrother;
		}
	}
	void postOrder(int n)
	{
		int m = data[n].lchild;
		while (m != 0)
		{
			postOrder(m);
			m = data[m].nextBrother;
		}
		cout << data[n].v << ' ';
	}
public:
	staticBTree() :data(NULL), size(0),root(0) {}
	~staticBTree()
	{
		if (data != NULL) delete[]data;
	}
	void getRoot()
	{
		int i = 1;
		while (data[i].father != 0)
			i = data[i].father;
		root = i;
	}
	void createTree(int N)
	{
		size = N;
		data = new node[N + 1];
		int p, q, v;
		for (int i = 1;i <= N;++i)
		{
			cin >> p >> q >> v;
			data[i].lchild = p;
			data[i].nextBrother = q;
			data[i].v = v;
			data[p].father = data[q].father = i;
		}
		getRoot();
	}
	void preOrder()
	{
		preOrder(root);
		cout << '\n';
	}
	void postOrder()
	{
		postOrder(root);
		cout << '\n';
	}
	void levelTraverse()
	{
		memset(que, 0, sizeof(que));
		int head = 0;
		int back = 0;
		que[back++] = root;
		int tmp;
		while (head != back)
		{
			tmp = que[head++];
			cout << data[tmp].v << ' ';
			tmp = data[tmp].lchild;
			while (tmp != 0)
			{
				que[back++] = tmp;
				tmp = data[tmp].nextBrother;
			}
		}
		cout << '\n';
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int N;
	cin >> N;
	staticBTree bt;
	bt.createTree(N);
	bt.preOrder();
	bt.postOrder();
	bt.levelTraverse();
	cin.get();
	cin.get();
	return 0;
}

1215

#include <iostream>
using namespace std;
 
class bernoulli
{
private:
	struct node
	{
		int data;
		node *son, *brother;
 
		node() {}
		node(int x, node *p = NULL, node *q = NULL) :data(x), son(p), brother(q) {}
	};
 
	node **forest;
	int len;
 
	node* merge(node *t1,node *t2)
	{
		if (t1->data > t2->data)
			return merge(t2, t1);
		t2->brother = t1->son;
		t1->son = t2;
		return t1;
	}
 
	void clear(node *p)
	{
		if (p)
		{
			node *tmp = p->son;
			delete p;
			while (tmp)
			{
				p = tmp->brother;
				clear(tmp);
				tmp = p;
			}
		}
	}
public:
	bernoulli()
	{
		forest = new node*[20]();
		len = 20;
	}
	~bernoulli()
	{
		for (int i = 0;i < len;++i) clear(forest[i]);
		delete[]forest;
	}
	void insert(int x)
	{
		node *tmp = new node(x);
		int i;
		for (i = 0;i < len;++i)
		{
			if (!forest[i]) break;
			tmp = merge(forest[i], tmp);
			forest[i] = NULL;
		}
		forest[i] = tmp;
	}
	void pop()
	{
		int min = 0x7fffffff;
		int pos = -1;
		for (int i = 0;i < len;++i)
		{
			if (forest[i]&&forest[i]->data < min)
			{
				min = forest[i]->data;
				pos = i;
			}
		}
		node *tmp[20] = { NULL };
		int i = pos-1;
		node *res = forest[pos]->son;
		while (res)
		{
			tmp[i--] = res;
			res = res->brother;
			tmp[i + 1]->brother = NULL; //因为插入用的是反序。
		}
		delete forest[pos];
		forest[pos] = NULL;
		node* carry = NULL;
		for (i = 0;i <= pos;++i)
		{
			if (forest[i] && tmp[i])
			{
				if (carry)carry = merge(carry, tmp[i]);
				else
				{
					carry = merge(forest[i], tmp[i]);
					forest[i] = NULL;
				}
			}
			else
			{
				if (carry)
				{
					if (forest[i] || tmp[i])
					{
						carry = merge((tmp[i] == NULL ? forest[i] : tmp[i]), carry);
						forest[i] = NULL;
					}
					else
					{
						forest[i] = carry;
						carry = NULL;
					}
				}
				else
				{
					if (!forest[i])forest[i] = tmp[i];
				}
			}
		}
	}
	int front() const
	{
		int min = 0x7fffffff;
		for (int i = 0;i < len;++i) 
			if (forest[i]&&forest[i]->data < min) min = forest[i]->data;
		return min;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	bernoulli b;
	int M;
	cin >> M;
	char command[7];
	int n;
	for (int i = 0;i < M;++i)
	{
		cin >> command;
		switch (command[0])
		{
		case 'i':cin >> n;
			b.insert(n);
			break;
		case 'd':b.pop();
			break;
		case 'm':cout << b.front() << '\n';
		}
	}
	cin.get();
	cin.get();
	return 0;
}

1216

#include <iostream>
using namespace std;
 
class heap
{
private:
	int *data;
	int maxSize;
	int size;
	
	void doubleSpace()
	{
		int *tmp = data;
		data = new int[maxSize * 2 + 1];
		for (int i = 1;i <= size;++i) data[i] = tmp[i];
		delete[]tmp;
		maxSize *= 2;
	}
 
public:
	heap(int capacity = 10) :maxSize(capacity), size(0), data(new int[capacity + 1]) {}
	~heap() { delete[]data; }
	void enQueue(int n)
	{
		if (size == maxSize)doubleSpace();
		int hole = ++size;
		for (;hole > 1 && n < data[hole >> 1];hole = hole >> 1)data[hole] = data[hole >> 1];
		data[hole] = n;
	}
	int find(int t, int n)
	{
		if (t > size)return 0;
		if (data[t] > n)return t;
		int l = find(t << 1, n), r = find((t << 1) + 1, n);
		if (l&&r)
		{
			if (data[l] == data[r])
			{
				return (l < r ?  l : r);
			}
			else return (data[l] < data[r] ? l : r);
		}
		else if (l)return l;
		else if (r) return r;
		else return 0;
	}
	void decrease(int i, int d)
	{
		int tmp = data[i] - d;
		for (;i > 1 && tmp < data[i >> 1];i = i >> 1)data[i] = data[i >> 1];
		data[i] = tmp;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	heap h;
	int M;
	cin >> M;
	char command[10];
	int n, m;
	for (int i = 0;i < M;++i)
	{
		cin >> command;
		switch (command[0])
		{
		case 'i':
			cin >> n;
			h.enQueue(n);
			break;
		case 'f':
			cin >> n;
			cout << h.find(1, n) << '\n';
			break;
		case 'd':
			cin >> n >> m;
			h.decrease(n, m);
		}
	}
	cin.get();
	cin.get();
	return 0;
}

1217

#include <iostream>
using namespace std;
 
struct node
{
	int data;
	bool state;
 
	node() :state(false) {}
};
 
class hashTable
{
private:
	node arr[100007];
public:
	void insert(int n)
	{
		int pos = n % 100007;
		while (arr[pos].state) pos = (pos + 1) % 100007;
		arr[pos].data = n;
		arr[pos].state = true;
	}
	bool find(int n)
	{
		int pos = n % 100007;
		while (arr[pos].state)
		{
			if (arr[pos].data == n)return true;
			pos = (pos + 1) % 100007;
		}
		return false;
	}
};
 
int main()
{
	int n, m;
	hashTable h;
	cin >> n;
	for (int i = 0;i < n;++i)
	{
		cin >> m;
		h.insert(m);
	}
	cin >> m;
	for (int i = 0;i < m;++i)
	{
		cin >> n;
		cout << (h.find(n) ? 'Y' : 'N') << endl;
	}
	cin.get();
	cin.get();
	return 0;
}

1218

#include <iostream>
using namespace std;
 
int mid(int a, int b, int c)
{
	if (a < b)
	{
		if (b < c)return b;
		else if (c < a) return a;
		else return c;
	}
	else
	{
		if (a < c) return a;
		else if (c < b) return b;
		else return c;
	}
}
 
void partition(int arr[], int begin, int end, int& newEnd, int& newBegin)
{
	int pivot = mid(arr[begin], arr[end], arr[(begin + end)/2]);
	int pos = begin;
	while (pos <= end)
	{
		if (arr[pos] < pivot)
		{
			int tmp = arr[pos];
			arr[pos++] = arr[begin];
			arr[begin++] = tmp;
		}
		else if (arr[pos] > pivot)
		{
			int tmp = arr[pos];
			arr[pos] = arr[end];
			arr[end--] = tmp;
		}
		else ++pos;
	}
	newEnd = begin - 1;
	newBegin = end + 1;
}
 
void quick_sort(int arr[], int begin, int end)
{
	if (begin < end)
	{
		int newEnd, newBegin;
		partition(arr, begin, end, newEnd, newBegin);
		quick_sort(arr, begin, newEnd);
		quick_sort(arr, newBegin, end);
	}
}
 
class set
{
	friend istream& operator >> (istream &is, set& s)
	{
		for (int i = 0;i < s.size;++i)
			is >> s.data[i];
		return is;
	}
	friend ostream& operator<<(ostream &os, const set& s)
	{
		for (int i = 0;i < s.size;++i) os << s.data[i] << ' ';
		return os;
	}
private:
	int *data;
	int size;
	int maxSize;
 
	int find(int n) const
	{
		int l = 0, r = size - 1;
		while (l <= r)
		{
			if (data[l] >= n) break;
			int mid = (l + r) / 2;
			if (data[mid] < n)l = mid + 1;
			else r = mid;
		}
		return l;
	}
public:
	set(int sz, int cp = 10000) :size(sz), maxSize(cp) { data = new int[maxSize]; }
	~set() { delete[]data; }
	void operator+(const set& other)
	{
		for (int i = 0;i < other.size;++i)
		{
			int pos = find(other.data[i]);
			if (pos == size)data[size++] = other.data[i];
			else if (data[pos] > other.data[i])
			{
				for (int j = size++;j > pos;--j) data[j] = data[j - 1];
				data[pos] = other.data[i];
			}
		}
	}
	void operator-(const set& other)
	{
		for (int i = 0;i < other.size;++i)
		{
			int pos = find(other.data[i]);
			if (pos < size&&data[pos] == other.data[i])
			{
				for (int j = pos;j < size - 1;++j) data[j] = data[j + 1];
				--size;
			}
		}
	}
	void operator*(const set& other)
	{
		int *tmp = new int[maxSize];
		int cnt = 0;
		int i, j;
		quick_sort(other.data,0,other.size-1);
		if (other.size > 0) i = find(other.data[0]);
		for (j = 0;j < other.size;++j)
		{
			for (;i < size;++i)
				if (data[i] >= other.data[j]) break;
			if (i == size) break;
			else if (data[i] == other.data[j]) tmp[cnt++] = data[i];
		}
		delete[]data;
		data = tmp;
		size = cnt;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	set s(0);
	int m;
	char c;
	for (int i = 0;i < n;++i)
	{
		cin >> c >> m;
		set s2(m);
		cin >> s2;
		switch (c)
		{
		case '+':
			s + s2;
			cout << s << '\n';
			break;
		case '-':
			s - s2;
			cout << s << '\n';
			break;
		case '*':
			s * s2;
			cout << s << '\n';
		}
	}
	cin.get();
	cin.get();
	return 0;
}

1219

#include <iostream>
using namespace std;
 
struct node
{
	int val;
	int pos;
	node() {}
	node(int v, int i) :val(v), pos(i) {}
};
 
int arr[200000];
int cmpArr[200000];
node tmpCpy[400000];
int *treeArr;
int treeSize;
int stack[400000];
 
int partition(node arr[], int begin, int end)
{
	node pivot = arr[begin];
	while (begin < end)
	{
		while (begin < end&&arr[end].val >= pivot.val)--end;
		arr[begin] = arr[end];
		while (begin < end&&arr[begin].val <= pivot.val)++begin;
		arr[end] = arr[begin];
	}
	arr[begin] = pivot;
	return begin;
}
 
void quick_sort(node arr[], int begin, int end)
{
	int p = -1;
	stack[++p] = begin;
	stack[++p] = end;
	while (p!=-1)
	{
		end = stack[p--];
		begin = stack[p--];
		if (begin < end)
		{
			int mid = partition(arr, begin, end);
			stack[++p] = mid + 1;
			stack[++p] = end;
			stack[++p] = begin;
			stack[++p] = mid - 1;
		}
	}
}
 
void add(int x, int y)
{
	for (int i = x;i < treeSize;i += i&-i) treeArr[i] += y;
}
 
long long query(int x)
{
	long long sum = 0;
	for (int i = x;i > 0;i -= i&-i)sum += treeArr[i];
	return sum;
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	for (int i = 0;i < n;++i)
	{
		cin >> arr[i];
		tmpCpy[i] = node(arr[i], i);
		tmpCpy[i + n] = node(arr[i] * 2, i + n);
	}
	quick_sort(tmpCpy, 0, 2 * n - 1);
	int newData = 1;
	if (tmpCpy[0].pos < n)arr[tmpCpy[0].pos] = newData;
	else cmpArr[tmpCpy[0].pos - n] = newData;
	for (int i = 1;i < 2 * n;++i)
	{
		if (tmpCpy[i].val > tmpCpy[i - 1].val)++newData;
		if (tmpCpy[i].pos < n)arr[tmpCpy[i].pos] = newData;
		else cmpArr[tmpCpy[i].pos - n] = newData;
	}
	treeSize = newData + 1;
	treeArr = new int[treeSize]();
	long long result = 0;
	for (int i = 0;i < n;++i)
	{
		add(arr[i], 1);
		result += i + 1 - query(cmpArr[i]);
	}
	cout << result << '\n';
	delete[]treeArr;
	cin.get();
	cin.get();
	return 0;
}

1221

#include <iostream>
using namespace std;
#define INF 1<<31
 
class  BinarySearchTree
{
private:
	struct node
	{
		int data, cnt;
		node *left, *right;
 
		node(int d, node *p = NULL, node *q = NULL) :data(d), cnt(1), left(p), right(q) {}
	}*root;
 
	void makeEmpty(node *&p)
	{
		if (p)
		{
			makeEmpty(p->left);
			makeEmpty(p->right);
			delete p;
			p = NULL;
		}
	}
	void insert(node *&t, int x)
	{
		if (t)
		{
			if (t->data > x)insert(t->left,x);
			else if (t->data < x) insert(t->right, x);
			else ++t->cnt;
		}
		else t = new node(x);
	}
	void del(node *&t, int x)
	{
		if (!t)return;
		if (x < t->data)del(t->left, x);
		else if (x > t->data)del(t->right, x);
		else if (t->cnt > 1)--t->cnt;
		else if (t->left&&t->right)
		{
			node *tmp = t->right;
			while (tmp->left)tmp = tmp->left;
			t->data = tmp->data;
			t->cnt = tmp->cnt;
			tmp->cnt = 1;
			del(t->right, tmp->data);
		}
		else
		{
			node *old = t;
			t = (t->left ? t->left : t->right);
			delete old;
		}
	}
	void delBetween(node *&t, int x, int y)
	{
		if (!t) return;
		if (x >= t->data)delBetween(t->right, x, y);
		else if (y <= t->data)delBetween(t->left, x, y);
		else
		{
			delBetween(t->left, x, y);
			delBetween(t->right, x, y);
			if (t->right)
			{
				node *tmp = t->right;
				while (tmp->left)tmp = tmp->left;
				t->data = tmp->data;
				t->cnt = tmp->cnt;
				tmp->cnt = 1;
				del(t->right, tmp->data);
			}
			else if(t->left)
			{
				node *tmp = t->left;
				while (tmp->right) tmp = tmp->right;
				t->data = tmp->data;
				t->cnt = tmp->cnt;
				tmp->cnt = 1;
				del(t->left, tmp->data);
			}
			else t = NULL;
		}
	}
 
	int find_ith(node *t, int& i)
	{
		if (!t)return INF;
		int search1 = find_ith(t->left, i);
		if (search1 != INF) return search1;
		else
		{
			if (i <= t->cnt)return t->data;
			else
			{
				i -= t->cnt;
				return find_ith(t->right, i);
			}
		}
	}
public:
	BinarySearchTree(node *p = NULL) :root(p) {}
	~BinarySearchTree() { makeEmpty(root); }
	void insert(int x) { insert(root, x); }
	void del(int x) { del(root, x); }
	void delBetween(int x,int y) { delBetween(root, x, y); }
	bool find(int x)
	{
		if (!root) return false;
		node *tmp = root;
		while (tmp)
		{
			if (tmp->data > x)tmp = tmp->left;
			else if (tmp->data < x)tmp = tmp->right;
			else return true;
		}
		return false;
	}
	int find_ith(int i)
	{
		return find_ith(root, i);
	}
};
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	char command[20];
	int a, b;
	cin >> n;
	BinarySearchTree t;
	for (int i = 0;i < n;++i)
	{
		cin >> command;
		switch (command[0])
		{
		case 'i':
			cin >> a;
			t.insert(a);
			break;
		case 'd':
			if (command[6])
			{
				switch (command[7])
				{
				case 'l':
					cin >> a;
					t.delBetween(INF,a);
					break;
				case 'g':
					cin >> a;
					t.delBetween(a,0x7fffffff);
					break;
				case 'i':
					cin >> a >> b;
					t.delBetween(a, b);
				}
			}
			else
			{
				cin >> a;
				t.del(a);
			}
			break;
		case 'f':
			if (command[4])
			{
				cin >> a;
				int ans = t.find_ith(a);
				if (ans == INF) cout << "N\n";
				else cout << ans << '\n';
			}
			else
			{
				cin >> a;
				cout << (t.find(a) ? 'Y' : 'N') << '\n';
			}
		}
	}
	cin.get();
	cin.get();
	return 0;
}

1224

// 1224. hash.cpp : 定义控制台应用程序的入口点。
//
 
#include <iostream>
#include <fstream>
#include <cstdio>
using namespace std;
 
int n;
int ht[4000000];
int cnt[4000000] = { 0 };
int a[505], b[505], c[505], d[505];
 
int find(int x) {
	int tmp = x >= 0 ? x : -x;
	int pos = tmp;
	while (1) {
		if (cnt[pos] == 0) return 0;
		if (ht[pos] == x) return cnt[pos];
		else pos++;
	}
}
void ins(int x) {
	int tmp = x >= 0 ? x : -x;
	int pos = tmp;
	while (1) {
		if (cnt[pos] == 0) {
			cnt[pos]++;
			ht[pos] = x;
			return;
		}
		if (ht[pos] == x) {
			cnt[pos]++;
			return;
		}
		pos++;
	}
}
 
int main()
{
	cin >> n;
	int ans = 0;
	for (int i = 1; i <= n; ++i) cin >> a[i] >> b[i] >> c[i] >> d[i];
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			ins(-(a[i] + b[j]));
 
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			ans += find(c[i] + d[j]);
 
	cout << ans << endl;
	return 0;
}

#include <iostream>
using namespace std;
 
struct node
{
	int key, cnt;
	node *next;
 
	node() :next(NULL) {}
	node(int k) :key(k), cnt(1), next(NULL) {}
};
 
class hashTable
{
private:
	node *data;
	int size;
public:
	hashTable(int length=100007) :size(length), data(new node[length]) {}
	~hashTable() 
	{
		for (int i = 0;i < size;++i)
		{
			node *p = data[i].next;
			while (p)
			{
				node *q = p;
				p = p->next;
				delete q;
			}
		}
		delete[]data;
	}
	node *find(int k) const
	{
		int pos = (k+10000700) % 100007;
		node *p = &data[pos];
		while (p->next&&p->next->key != k)p = p->next;
		return p;
	}
	void insert(int k)
	{
		node *p = find(k);
		if (p->next)++p->next->cnt;
		else p->next = new node(k);
	}
};
 
int main()
{
	int n;
	cin >> n;
	int arr[4][500];
	for (int i = 0;i < n;++i) cin >> arr[0][i] >> arr[1][i] >> arr[2][i] >> arr[3][i];
	hashTable hs;
	for (int i = 0;i < n;++i)
		for (int j = 0;j < n;++j)
			hs.insert(arr[0][i] + arr[1][j]);
	int ans = 0;
	for(int i=0;i<n;++i)
		for (int j = 0;j < n;++j)
		{
			node *p = hs.find(-arr[2][i] - arr[3][j]);
			if (p->next)ans += p->next->cnt;
		}
	cout << ans << endl;
	cin.get();
	cin.get();
	return 0;
}

1225

#include <iostream>
using namespace std;
 
int mid(int a, int b, int c)
{
	if (a > b)
	{
		if (b > c)return b;
		else if (c > a)return a;
		else return c;
	}
	else
	{
		if (a > c)return a;
		else if (c > b)return b;
		else return c;
	}
}
 
void partition(int arr[], int begin, int end, int& newEnd, int& newBegin)
{
	int pivot = mid(arr[begin], arr[end], arr[begin + end >> 1]);
	int pos = begin;
	while (pos <= end)
	{
		if (arr[pos] < pivot)
		{
			int tmp = arr[begin];
			arr[begin++] = arr[pos];
			arr[pos++] = tmp;
		}
		else if (arr[pos] > pivot)
		{
			int tmp = arr[end];
			arr[end--] = arr[pos];
			arr[pos] = tmp;
		}
		else ++pos;
	}
	newEnd = begin - 1;
	newBegin = end + 1;
}
 
void quickSort(int arr[], int begin, int end)
{
	if (begin < end)
	{
		int newEnd, newBegin;
		partition(arr, begin, end, newEnd, newBegin);
		quickSort(arr, begin, newEnd);
		quickSort(arr, newBegin, end);
	}
}
 
int arr[2000000];
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int N;
	cin >> N;
	for (int i = 0;i < N;++i) cin >> arr[i];
	quickSort(arr, 0, N - 1);
	int ans = 1;
	for (int i = 1;i < N;++i)
	{
		if (arr[i] != arr[i - 1]) ++ans;
	}
	cout << ans << '\n';
	cin.get();
	cin.get();
	return 0;
}

1226

#include <iostream>
using namespace std;
 
int partition(int *arr, int begin, int end)
{
	int pivot = arr[begin];
	while (begin < end)
	{
		while (begin<end&&arr[end] >= pivot)--end;
		arr[begin] = arr[end];
		while (begin<end&&arr[begin] <= pivot)++begin;
		arr[end] = arr[begin];
	}
	arr[begin] = pivot;
	return begin;
}
 
void quickSort(int *arr, int begin, int end)
{
	if (begin < end)
	{
		int mid = partition(arr, begin, end);
		quickSort(arr, begin, mid - 1);
		quickSort(arr, mid + 1, end);
	}
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int N;
	cin >> N;
	int *arr = new int[N];
	for (int i = 0;i < N;++i)
		cin >> arr[i];
	quickSort(arr, 0, N - 1);
	for (int i = 0;i < N;++i)
		cout << arr[i] << ' ';
	cout << '\n';
	cin.get();
	cin.get();
	delete[]arr;
	return 0;
}

1227

#include <iostream>
using namespace std;
 
class linkList
{
private:
	struct node
	{
		int num;
		node *next;
 
		node():next(NULL) {}
		node(int n, node* p = NULL) :num(n), next(p) {}
	};
	node *head;
	node *rear;
public:
	linkList()
	{
		rear = head = new node;
	}
	~linkList()
	{
		node *p = head->next;
		while (p)
		{
			node *q = p->next;
			delete p;
			p = q;
		}
		delete head;
	}
	void add(int n)
	{
		rear = rear->next = new node(n);
	}
	void sort()
	{
		node *p = head->next;
		for (;p;p = p->next)
		{
			node *tmp = p;
			node *q = p->next;
			for (;q;q = q->next)
			{
				if (q->num < tmp->num)tmp = q;
			}
			if (tmp != p)
			{
				int anum = p->num;
				p->num = tmp->num;
				tmp->num = anum;
			}
		}
	}
	void traverse()
	{
		node *p = head->next;
		for (;p;p = p->next)
		{
			cout << p->num << ' ';
		}
		cout << endl;
	}
};
 
int main()
{
	int n;
	cin >> n;
	linkList l;
	int num;
	for (int i = 0;i < n;++i)
	{
		cin >> num;
		l.add(num);
	}
	l.sort();
	l.traverse();
	cin.get();
	cin.get();
	return 0;
}

1228

#include <iostream>
using namespace std;
 
bool sum[401][401];
long long dp[401][2] = { 0 };
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	int tmp;
	long long ans1 = 0;
	long long ans2 = 0;
	for (int i = 1;i <= n;++i)
		for (int j = 1;j <= n;++j)
		{
			cin >> tmp;
			sum[i][j] = tmp & 1;
			if (sum[i - 1][j])sum[i][j] = !sum[i][j];
		}
	for(int i=1;i<=n;++i)
		for (int j = i;j <= n;++j)
		{
			for (int k = 1;k <= n;++k)
			{
				if ((sum[j][k] + sum[i - 1][k]) & 1)
				{
					dp[k][0] = dp[k - 1][1];
					dp[k][1] = dp[k - 1][0] + 1;
				}
				else
				{
					dp[k][0] = dp[k - 1][0] + 1;
					dp[k][1] = dp[k - 1][1];
				}
				ans2 += dp[k][0];
				ans1 += dp[k][1];
			}
		}
	cout << ans1 << ' ' << ans2 << endl;
	cin.get();
	cin.get();
	return 0;
}

1231

#include <iostream>
using namespace std;
 
int N, X, Y;
 
struct node
{
	int left, right, parent;
	node() :left(0), right(0),parent(0) {}
};
 
node *tree;
 
class disjointSet
{
private:
	int *parent;
public:
	disjointSet(int n)
	{
		parent = new int[n + 1];
		for (int i = 0;i < n;++i)parent[i + 1] = -1;
		parent[0] = 0;
	}
	~disjointSet()
	{
		delete[]parent;
	}
	int find(int x)
	{
		if(parent[x]<0)return x;
		return parent[x]=find(parent[x]);
	}
	void merge(int root1, int root2)
	{
		if (tree[root1].parent == root2)
		{
			parent[root2] += parent[root1];
			parent[root1] = root2;
		}
		else
		{
			parent[root1] += parent[root2];
			parent[root2] = root1;
		}
	}
};
 
int LCA(disjointSet& d,node *t, int root)
{
	if (!root)return -1;
	int tmp;
	if ((tmp = LCA(d, t, t[root].left)) > 0)return tmp;
	else if ((tmp = LCA(d, t, t[root].right) > 0))return tmp;
	else
	{
		if (t[root].left)d.merge(root, t[root].left);
		if (t[root].right)d.merge(root, t[root].right);
		if ((tmp = d.find(X)) == d.find(Y))return tmp;
		else return -1;
	}
}
 
int main()
{
	cin >> N >> X >> Y;
	tree = new node[N + 1];
	for (int i = 1;i <= N;++i)
	{
		cin >> tree[i].left >> tree[i].right;
		tree[tree[i].left].parent = tree[tree[i].right].parent = i;
	}
	int root = 1;
	while (tree[root].parent)root = tree[root].parent;
	disjointSet d(N);
	cout << LCA(d, tree, root) << endl;
	delete[]tree;
	cin.get();
	cin.get();
	return 0;
}

1232

#include <iostream>
using namespace std;
 
int N;
int A, B;
 
int getX(int P)
{
	int l = 1, r = N;
	while (l <= r)
	{
		int mid = l + r >> 1;
		if ((mid*(mid + 1) >> 1) < P)l = mid + 1;
		else r = mid - 1;
	}
	return l;
}
 
inline int getP(int x, int y)
{
	return ((x*(x - 1) >> 1) + y);
}
 
class disjointSet
{
private:
	int *parent;
public:
	disjointSet(int n) :parent(new int[n + 1])
	{
		for (int i = 1;i <= n;++i) parent[i] = -1;
	}
	~disjointSet() { delete[]parent; }
	int find(int x)
	{
		if (parent[x] < 0)return x;
		else
		{
			int tmp = parent[x];
			while (parent[tmp] > 0)tmp = parent[tmp];
			int y;
			while (x != tmp)
			{
				y = parent[x];
				parent[x] = tmp;
				x = y;
			}
			return tmp;
		}
	}
	void merge(int root1, int root2)
	{
		if (root1 == root2)return;
		if (parent[root1] < parent[root2])
		{
			parent[root1] += parent[root2];
			parent[root2] = root1;
		}
		else
		{
			parent[root2] += parent[root1];
			parent[root1] = root2;
		}
	}
};
 
bool *mark;
bool **access;
int *path;
int pos = 0;
 
bool dfs(int x, int y)
{
	mark[getP(x,y)] = true;
	if (getP(x, y) == B) return true;
	if (access[0][getP(x, y)] && !mark[getP(x - 1, y - 1)])
	{
		if (dfs(x-1,y-1))
		{
			path[pos++] = getP(x - 1, y - 1);
			return true;
		}
	}
	if (access[1][getP(x, y)] && !mark[getP(x - 1, y)])
	{
		if (dfs(x-1,y))
		{
			path[pos++] = getP(x - 1, y);
			return true;
		}
	}
	if ( access[2][getP(x, y)] && !mark[getP(x + 1, y)])
	{
		if (dfs(x+1,y))
		{
			path[pos++] = getP(x + 1, y);
			return true;
		}
	}
	if (access[3][getP(x, y)] && !mark[getP(x + 1, y + 1)])
	{
		if (dfs(x+1,y+1))
		{
			path[pos++] = getP(x + 1, y + 1);
			return true;
		}
	}
	return false;
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> N >> A >> B;
	int P, Q;
	int x, y;
	access = new bool*[4];
	for(int i=0;i<4;++i)access[i] = new bool[(N*(N + 1) >> 1) + 1]();
	disjointSet s(N*(N + 1) >> 1);
	while (cin >> P >> Q)
	{
		x = getX(P);
		y = P - (x*(x - 1) >> 1);
		switch (Q)
		{
		case 0:
			if (y != 1)
			{
				s.merge(s.find(P), s.find(P - x));
				access[0][P] = access[3][P - x] = true;
			}
			break;
		case 1:
			if (y != x)
			{
				s.merge(s.find(P), s.find(P - x + 1));
				access[1][P] = access[2][P - x + 1] = true;
			}
			break;
		case 2:
			if (x != N)
			{
				s.merge(s.find(P), s.find(P + x));
				access[2][P] = access[1][P + x] = true;
			}
			break;
		case 3:
			if (x != N)
			{
				s.merge(s.find(P), s.find(P + x + 1));
				access[3][P] = access[0][P + x + 1] = true;
			}
		}
		if (s.find(A) == s.find(B))break;
	}
	x = getX(A);
	y = A - (x*(x - 1) >> 1);
	mark = new bool[(N*(N + 1) >> 1) + 1]();
	path = new int[(N*(N + 1) >> 1)]();
	if (dfs(x, y)) path[pos++] = A;
	for (int i = pos - 1;i >= 0;--i) cout << path[i] << ' ';
	cout << '\n';
	delete[]mark;
	delete[]path;
	for (int i = 0;i < 4;++i)delete[]access[i];
	delete[]access;
	cin.get();
	cin.get();
	return 0;
}

1233

#include <iostream>
using namespace std;
 
int n, m, start, M;
int ans = 0;
bool visited[11] = { false };
 
class adjustGraph
{
private:
	struct edgeNode
	{
		int end;
		edgeNode *next;
 
		edgeNode(int e,edgeNode *p = NULL) :end(e), next(p) {}
	};
	edgeNode **verList;
	int vers;
public:
	adjustGraph(int vSize) :vers(vSize),verList(new edgeNode*[vSize + 1]()) {}
	~adjustGraph()
	{
		for (int i = 1;i <= vers;++i)
		{
			if (verList[i])
			{
				edgeNode*p = verList[i]->next;
				while (p)
				{
					edgeNode *q = p->next;
					delete p;
					p = q;
				}
			}
		}
		delete[]verList;
	}
	bool insert(int u, int v)
	{
		verList[u] = new edgeNode(v, verList[u]);
		return true;
	}
	void dfs(int s,int l)
	{
		if (l == 0)
		{
			++ans;
			return;
		}
		if (verList[s])
		{
			edgeNode *p = verList[s];
			while (p)
			{
				if (!visited[p->end])
				{
					visited[p->end] = true;
					dfs(p->end, l - 1);
					visited[p->end] = false;
				}
				p = p->next;
			}
		}
	}
};
 
int main()
{
	cin >> n >> m >> start >> M;
	adjustGraph g(n);
	int u, v;
	for (int i = 0;i < m;++i)
	{
		cin >> u >> v;
		g.insert(u, v);
	}
	visited[start] = true;
	g.dfs(start, M);
	cout << ans << endl;
	cin.get();
	cin.get();
	return 0;
}

1234

#include <iostream>
using namespace std;
//Prim
 
struct edgeNode
{
	int end;
	int weight;
	edgeNode *next;
 
	edgeNode(int e, int w, edgeNode *p = NULL) :end(e), weight(w), next(p) {}
};
 
class adjList
{
private:
	edgeNode **verList;
	int vers;
public:
	adjList(int sz) :verList(new edgeNode*[sz + 1]()), vers(sz) {}
	~adjList()
	{
		for (int i = 1;i <= vers;++i)
		{
			edgeNode *p = verList[i];
			while (p)
			{
				edgeNode *q = p->next;
				delete p;
				p = q;
			}
		}
		delete[]verList;
	}
	void insert(int u, int v, int w)
	{
		verList[u] = new edgeNode(v, w, verList[u]);
	}
	edgeNode* vat(int i)
	{
		return verList[i];
	}
};
 
struct edge
{
	int begin, end, weight;
};
 
class heap
{
private:
	int size;
	edge *data;
 
	void percolateDown(int hole)
	{
		edge tmp = data[hole];
		int child;
		for (;(hole << 1) <= size;hole = child)
		{
			child = hole << 1;
			if (child + 1 <= size&&data[child + 1].weight < data[child].weight)++child;
			if (tmp.weight > data[child].weight)data[hole] = data[child];
			else break;
		}
		data[hole] = tmp;
	}
public:
	heap(int capacity) :size(0), data(new edge[capacity + 1]()) {}
	~heap() { delete[]data; }
	void insert(edge e)
	{
		int hole = ++size;
		for (;hole > 1 && e.weight < data[hole >> 1].weight;hole = hole >> 1)
			data[hole] = data[hole >> 1];
		data[hole] = e;
	}
	edge pop()
	{
		edge tmp = data[1];
		data[1] = data[size--];
		percolateDown(1);
		return tmp;
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, m;
	cin >> n >> m;
	adjList graph(n);
	heap h(m);
	bool visited[10005] = { false };
	int u, v, w;
	for (int i = 0;i < m;++i)
	{
		cin >> u >> v >> w;
		graph.insert(u, v, w);
		graph.insert(v, u, w);
	}
	int start = 1;
	visited[1] = true;
	int ans = 0;
	for(int i=1;i<n;++i)
	{
		edgeNode* vert = graph.vat(start);
		edge tmp;
		tmp.begin = start;
		while (vert)
		{
			if (!visited[vert->end])
			{
				tmp.end = vert->end;
				tmp.weight = vert->weight;
				h.insert(tmp);
			}
			vert = vert->next;
		}
		tmp = h.pop();
		while (visited[tmp.end])tmp = h.pop();
		start = tmp.end;
		visited[start] = true;
		ans += tmp.weight;
	}
	cout << ans << '\n';
	cin.get();
	cin.get();
	return 0;
}

#include <iostream>
using namespace std;
 
class disjointSet
{
private:
	int *parent;
public:
	disjointSet(int sz) :parent(new int[sz + 1])
	{
		for (int i = 1;i <= sz;++i)parent[i] = -1;
	}
	~disjointSet() { delete[]parent; }
	int Find(int x)
	{
		if (parent[x] < 0)return x;
		return parent[x] = Find(parent[x]);
	}
	void Union(int root1, int root2)
	{
		if (root1 == root2)return;
		if (parent[root1] < parent[root2])
		{
			parent[root1] += parent[root2];
			parent[root2] = root1;
		}
		else
		{
			parent[root2] += parent[root1];
			parent[root1] = root2;
		}
	}
};
 
struct edge
{
	int begin, end, weight;
};
 
void percolateDown(edge arr[], int hole, int size)
{
	edge tmp = arr[hole];
	int child;
	for (;hole*2 <= size;hole = child)
	{
		child = hole << 1;
		if (child + 1 <= size&&arr[child + 1].weight < arr[child].weight)++child;
		if (arr[child].weight < tmp.weight)arr[hole] = arr[child];//此处应为tmp而不是arr[hole].
		else break;
	}
	arr[hole] = tmp;
}
 
edge arr[100005];
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, m;
	cin >> n >> m;
	for (int i = 1;i <= m;++i)cin >> arr[i].begin >> arr[i].end >> arr[i].weight;
	for (int i = m / 2;i > 0;--i)percolateDown(arr, i, m);
	disjointSet d(n);
	int ans = 0;
	int cnt = 0;
	for (int i = 0;i < m;++i)
	{
		percolateDown(arr, 1, m - i);
		int node1 = d.Find(arr[1].begin);
		int node2 = d.Find(arr[1].end);
		if (node1 != node2)
		{
			d.Union(node1, node2);
			ans += arr[1].weight;
			if (++cnt == n - 1)break;
		}
		arr[1] = arr[m - i];
	}
	cout << ans << '\n';
	cin.get();
	cin.get();
	return 0;
}

1235

#include <iostream>
using namespace std;
 
struct edgeNode
{
	int end;
	int weight;
	edgeNode *next;
 
	edgeNode(int e, int w, edgeNode* p = NULL) :end(e), weight(w), next(p) {}
};
 
class adjList
{
private:
	edgeNode **verList;
	int vers;
public:
	adjList(int sz) :vers(sz),verList(new edgeNode*[sz + 1]()) {}
	~adjList()
	{
		for (int i = 1;i <= vers;++i)
		{
			edgeNode *p = verList[i];
			while (p)
			{
				edgeNode *q = p->next;
				delete p;
				p = q;
			}
		}
		delete[]verList;
	}
	void insert(int u, int v, int w)
	{
		verList[u] = new edgeNode(v, w, verList[u]);
	}
	edgeNode* vat(int i)
	{
		return verList[i];
	}
};
 
struct vertex
{
	int num, distance, edges;
 
	vertex() :distance(0x7fffffff), edges(0) {}
	bool operator<(const vertex& v)
	{
		return distance < v.distance || distance == v.distance&&edges < v.edges;
	}
};
 
void percolateDown(vertex arr[], int hole, int size)
{
	vertex tmp = arr[hole];
	int child;
	for (;(hole << 1) <= size;hole = child)
	{
		child = hole << 1;
		if (child + 1 <= size&&arr[child + 1] < arr[child])++child;
		if (arr[child] < tmp)arr[hole] = arr[child];
		else break;
	}
	arr[hole] = tmp;
}
 
void ins(vertex arr[], vertex v, int size)
{
	int hole = ++size;
	for (;hole > 1 && v < arr[hole >> 1];hole = hole >> 1)
		arr[hole] = arr[hole >> 1];
	arr[hole] = v;
}
 
int heapSz;
vertex arr[200005];
 
void printPath(int start, int end, int last[])
{
	if (start == end)
	{
		cout << start << ' ';
		return;
	}
	printPath(start, last[end], last);
	cout << end << ' ';
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, m, start, end;
	cin >> n >> m >> start >> end;
	int last[10005];
	vertex result[10005];
	bool visited[10005] = { false };
	for (int i = 1;i <= n;++i)
	{
		result[i].num = arr[i].num = i;
	}
	result[start].distance = 0;
	heapSz = n;
	arr[1].num = start;
	arr[start].num = 1;
	last[start] = start;
	adjList graph(n);
	int u, v, w;
	for (int i = 0;i < m;++i)
	{
		cin >> u >> v >> w;
		graph.insert(u, v, w);
	}
	while(heapSz>0)
	{
		vertex pop = arr[1];
		arr[1] = arr[heapSz--];
		percolateDown(arr, 1, heapSz);
		if (!visited[pop.num])
		{
			int vnum = pop.num;
			visited[vnum] = true;
			//result[vnum] = pop;
			edgeNode *p = graph.vat(vnum);
			while (p)
			{
				if (!visited[p->end]&&(result[vnum].distance + p->weight < result[p->end].distance
					|| result[vnum].distance + p->weight == result[p->end].distance&&
					result[vnum].edges + 1 < result[p->end].edges))
				{
					vertex tmp;
					tmp.distance = result[vnum].distance + p->weight;
					tmp.edges = result[vnum].edges + 1;
					tmp.num = p->end;
					result[p->end] = tmp;
					ins(arr, tmp, heapSz++);
					last[p->end] = vnum;
				}
				p = p->next;
			}
		}
		if (visited[end])break;
	}
	cout << result[end].distance << '\n';
	printPath(start, end, last);
	cin.get();
	cin.get();
	return 0;
}

1236

#include <iostream>
using namespace std;
 
struct edgeNode
{
	int end;
	int weight;
	edgeNode *next;
 
	edgeNode(int e,int w, edgeNode *p = NULL) :end(e),weight(w), next(p) {}
};
 
class adjList
{
private:
	edgeNode **verList;
	int vers;
public:
	adjList(int sz) :vers(sz), verList(new edgeNode*[sz + 1]()) {}
	~adjList()
	{
		for (int i = 1;i <= vers;++i)
		{
			edgeNode *p = verList[i];
			while (p)
			{
				edgeNode *q = p->next;
				delete p;
				p = q;
			}
		}
		delete[]verList;
	}
	void insert(int u, int v, int w)
	{
		verList[u] = new edgeNode(v, w, verList[u]);
	}
	edgeNode *vat(int i)
	{
		return verList[i];
	}
};
 
int main()
{
	int n, m, start, end;
	cin >> n >> m >> start >> end;
	int u, v, w;
	adjList graph(n);
	for (int i = 0;i < m;++i)
	{
		cin >> u >> v >> w;
		graph.insert(u, v, w);
	}
	int q[105];
	int back = -1;
	int front = 0;
	int distance[11];
	for (int i = 1;i <= n;++i)distance[i] = 0x7fffffff;
	distance[start] = 0;
	q[++back] = start;
	int cur;
	while (front <= back)
	{
		cur = q[front++];
		edgeNode *vert = graph.vat(cur);
		while (vert)
		{
			if (distance[cur] + vert->weight < distance[vert->end])
			{
				distance[vert->end] = distance[cur] + vert->weight;
				q[++back] = vert->end;
			}
			vert = vert->next;
		}
	}
	cout << distance[end] << endl;
	cin.get();
	cin.get();
	return 0;
}

1237

#include <iostream>
using namespace std;
 
struct edgeNode
{
	int end;
	edgeNode *next;
 
	edgeNode(int e, edgeNode* p = NULL) :end(e), next(p) {}
};
 
class adjList
{
private:
	edgeNode **verList;
	int vers;
public:
	adjList(int sz) :vers(sz),verList(new edgeNode*[sz + 1]()) {}
	~adjList()
	{
		for (int i = 1;i <= vers;++i)
		{
			edgeNode *p = verList[i];
			while (p)
			{
				edgeNode *q = p->next;
				delete p;
				p = q;
			}
		}
		delete[]verList;
	}
	void insert(int u, int v)
	{
		verList[u] = new edgeNode(v,verList[u]);
	}
	edgeNode* vat(int i)
	{
		return verList[i];
	}
};
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, m, a, b;
	cin >> n >> m;
	adjList graph(n);
	int inDegree[10005] = { 0 };
	int sem[10005] = { 0 };
	for (int i = 0;i < m;++i)
	{
		cin >> a >> b;
		graph.insert(a, b);
		++inDegree[b];
	}
	int ans = 0;
	int q[10005];
	int front = 0, back = -1;
	for (int i = 1;i <= n;++i)
	{
		if (inDegree[i] == 0)
		{
			q[++back] = i;
			sem[i] = 1;
		}
	}
	int cur;
	while (front <= back)
	{
		cur = q[front++];
		if (sem[cur] > ans)ans = sem[cur];
		edgeNode *p = graph.vat(cur);
		while (p)
		{
			if (--inDegree[p->end] == 0)
			{
				q[++back] = p->end;
				sem[p->end] = sem[cur] + 1;
			}
			p = p->next;
		}
	}
	cout << ans << '\n';
	cin.get();
	cin.get();
	return 0;
}
BiWendong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
优先队列
weixin_30248399的博客
09-10 54
今天晚上没有白学，知道了有优先队列这回事了 先转一下经典blog：http://www.cppblog.com/shyli/archive/2007/04/06/21366.html 这里先些两种简单的方法 1.从大到小输出(最常用的一种方法) priority_queue<int> qi; 2.从小到大输出 priority_queue<int...
5、简单队列、优先队列
大宇的专栏
01-02 421
一、简单队列 function Queue() { let items = []; this.enqueue = element => { items.push(element); } this.dequeue = () => { return items.shift(); } this.fron...
二十二、数据结构之优先队列（二叉堆）-- 基础知识
蛋蛋
07-04 155
所谓的优先队列通俗点讲就是，当我们处理一些事情的时候我们通常会先处理比较重要或者需要处理的时间比较短的事情，而这个优先队列实现的就是这个思想，我们通过采取二叉搜索树的方式来进行实现二叉堆（数组实现)。学过二叉树的我们一定应该知道在一颗二叉树中一个结点X（根节点除外）所在的位置为i，那么他的父节点所在位置为i/2，左孩子为i*2，有孩子为i*2+1。由此性质，我们完全可以用数组来实现。 如...
C++ 优先队列的简单实现
weixin_30855761的博客
09-09 152
　　普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （largest-in，first-out）的行为特征。 STL中使用heap实现优先队列，底层容器使用的是vector。这里我们使用一个简单数组来代替vector。 以下是一个简单的优先队列实现方案： tem...
PAT|1125 Chain the Ropes(优先队列)
qq_43528044的博客
06-21 127
题目大意 给定一些绳段，您应该将它们链接成一根绳子。每次只能将两段折叠成环，然后将它们链接成一块，如图所示。由此产生的链条将被视为另一段绳索，可以再次折叠。每次链接后，原始两段的长度将减半。 解题分析 每次连结原来的绳子都要分别减半，因此首先链接短的 因此想到优先队列，每次取最小的两个进行操作，并将结果压回 代码 #include<bits/stdc++.h> using namespace std; priority_queue<int, vector<int>, gre
OJ IRC-开源
04-30
开源Java IRC客户端（以后可能还有服务器）应用程序编写项目...
农大OJ 1-163.zip
01-03
河南农业大学OJ答案（Java版）
HP officejet 5200系列打印机初始固件 OJ5200-1904A
11-23
全网唯一HP officejet 5200系列打印机初始固件 OJ5200_1904A，用于固件退回，专治升级固件后无法识别墨盒问题
算法课OJ作业-基于HTML的分治和动态规划源码.zip
最新发布
12-28
算法课OJ作业-基于HTML的分治和动态规划源码.zip算法课OJ作业-基于HTML的分治和动态规划源码.zip算法课OJ作业-基于HTML的分治和动态规划源码.zip算法课OJ作业-基于HTML的分治和动态规划源码.zip算法课OJ作业-基于...
课程资源 杭电OJ1000-1099答案
07-23
课程资源 杭电OJ1000-1099答案 ，仅供参考...
算法之路之征服上海交大的oj-1040. 二叉树层次遍历
Patrick的博客
09-05 402
/* 二叉树层次遍历 Description 给出一棵二叉树，求它的层次遍历结果。 [二叉树的遍历问题是一种精神，务必领会] Input Format 第一行，N&lt;1000000，表示二叉树节点数。 默认序号为0的节点为树根。接下来共N-1行， 依次表示序号为1，…，N-1的节点的父亲节点序号。 如果一个节点有两个孩子节点，左孩子节点序号总是小于右孩子节点序号。 Ou...
优先队列详解(转载)
weixin_30410119的博客
07-30 405
优先队列：顾名思义，首先它是一个队列，但是它强调了“优先”二字，所以，已经不能算是一般意义上的队列了，它的“优先”意指取队首元素时，有一定的选择性，即根据元素的属性选择某一项值最优的出队~ 百度百科上这样描述的： 　　优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素 　　优先队列的类定义　　 　　优先队列是0个或多个元素的集合,每个元素都有一个优先...
利用优先队列实现的dijkstra算法
alop or 导演 的专栏
03-15 4043
dijkstra算法是典型的贪心算法，但如果没有好的数据结构支持的话，O（v^2）的效率还是让人有点不满意，不过如果利用优先队列的话就能轻松的实现O(ElogV+VlogV),对       于稀疏图来说，这是很令人满意的！废话不多说，下面就是我的C++代码： #include #include #include #include using namespace std; #define
优先队列的数组实现（有序）
10-10 3805
优先队列上文介绍了一种方法，另一种方法就是在insert()方法中添加代码，将所有较大的元素向右边一定一格以使数组保持有序（和插入排序一样）。这样，最大的元素总会在数组的一边，优先队列的删除最大元素操作就和栈的pop()操作一样了。用数组实现优先队列：（insert已经进行有序操作。pop操作即为peekMax，remove操作）public class PriorityQ { privat
优先队列的用法
bool_isprime的专栏
09-04 1182
<br />在优先队列中，优先级高的元素先出队列。<br />标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。<br />优先队列的第一种用法，也是最常用的用法：priority_queue<int> qi;<br />通过<操作符可知在整数中元素大的优先级高。<br />故示例1中输出结果为：9 6 5 3 2<br /><br />第二种方法：<br />在示例1中，如果我们要把元素从小到大输出怎么办呢？<br />这时我们可以传入一个比较函数，使用functional.h函数对象作为比较函
Priority Queue(Heaps)--优先队列（堆）
热门推荐
changyuanchn的专栏
11-09 3万+
0）引论 前面已经有了链表，堆栈，队列，树等数据结构，尤其是树，是一个很强大的数据结构，能做很多事情，那么为什么还要引进一个优先队列的东东呢？它和队列有什么本质的不同呢？看一个例子，有一个打印机，但是有很多的文件需要打印，那么这些任务必然要排队等候打印机逐步的处理。这里就产生了一个问题。原则上说先来的先处理，但是有一个文件100页，它排在另一个1页的文件的前面，那么可能我们要先打印这个1页的文件
优先队列实现
虹少侠的博客
10-31 5723
简单说明 优先队列可以根据key值的大小将元素进行排序、先被pop的通常是优先级最高的。 优先队列的内部实现其实是利用了堆的数据结构、binary heap是一种完全二叉树、以大堆为例、每棵树的根节点的key值一定大于其子孙节点的key值、完全二叉树处了最底层的叶子节点外、其他位置都是填满的。这样我们可以利用数组来存储所有节点。 若将数组从下标1开始存储元素、那么下标为 i 的节点的左孩子节...
（SJTU OJ）1001.二哥摘苹果
*飛*的博客
01-28 523
1001. 二哥摘苹果 题目描述 二哥平日喜欢自己种一些东西，并以此为写程序和看电影之外的最大爱好。最近，二哥种的一棵苹果树到了采摘的时候，但是由于二哥身高的限制，有些苹果太高摘不到。于是二哥借来了一个凳子，踩在上面可以摘到更多的苹果。 二哥是一个懒于行动的人，他想在摘苹果之前知道自己能摘到多少苹果，如果实在太少（苹果树很茂盛，主要是由于身高原因），他宁可坐在树下等苹果自己掉下来砸到
【SJTUOJ笔记】P1056 二哥吃糖
FineArtz的博客
02-08 872
https://acm.sjtu.edu.cn/OnlineJudge/problem/1056    先看C操作。注意所有操作的参数都是糖果编号，但由于合并操作会将糖果打乱，所以我们需要设法快速找到特定编号的糖果在哪个盒子里。再加上C操作本身的合并，应该用并查集来实现这个功能。    再看Q操作。Q操作询问糖果数量第p多的盒子中有多少糖果，并且指明了1&lt;=p&lt;=10，相对于N是一个很...
杭电oj1000-1100
11-10
杭州电子科技大学在线评测系统（杭电OJ）中的题目1000-1100是一系列编程题，我将分别进行回答。 1000题是一个简单的入门题，要求计算两个整数的和。我们可以使用一个简单的算法，读取输入的两个整数，然后将它们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值