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