Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit e267148

Browse files
Apply Google C++ style guide using clang-format
1 parent 32c9b30 commit e267148

File tree

10 files changed

+252
-252
lines changed

10 files changed

+252
-252
lines changed

‎src/data_structures/fenwick_tree.cc

Lines changed: 19 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -7,26 +7,27 @@
77
using namespace std;
88

99
class FenwickTree {
10-
private:
11-
vector<int> tree;
12-
public:
13-
FenwickTree(int n) : tree(n + 1) {}
10+
private:
11+
vector<int> tree;
1412

15-
int range_sum(int pos) {
16-
++pos;
17-
int ret = 0;
18-
while (pos > 0) {
19-
ret += tree[pos];
20-
pos &= (pos - 1);
21-
}
22-
return ret;
13+
public:
14+
FenwickTree(int n) : tree(n + 1) {}
15+
16+
int range_sum(int pos) {
17+
++pos;
18+
int ret = 0;
19+
while (pos > 0) {
20+
ret += tree[pos];
21+
pos &= (pos - 1);
2322
}
23+
return ret;
24+
}
2425

25-
void update(int pos, int val) {
26-
++pos;
27-
while (pos < tree.size()) {
28-
tree[pos] += val;
29-
pos += (pos & -pos);
30-
}
26+
void update(int pos, int val) {
27+
++pos;
28+
while (pos < tree.size()) {
29+
tree[pos] += val;
30+
pos += (pos & -pos);
3131
}
32+
}
3233
};

‎src/data_structures/rankless_union_find.cc

Lines changed: 23 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -7,27 +7,28 @@
77
using namespace std;
88

99
class RanklessUnionFind {
10-
private:
11-
vector<int> p, rank, setSize;
12-
int numSets;
13-
public:
14-
RanklessUnionFind(int N) {
15-
setSize.assign(N, 1);
16-
numSets = N;
17-
rank.assign(N, 0);
18-
p.assign(N, 0);
19-
for (int i = 0; i < N; i++) p[i] = i;
20-
}
21-
intfindSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
22-
boolisSameSet(int i, int j) { return findSet(i) == findSet(j); }
23-
voidunionSet(int i, int j) {
24-
if (!isSameSet(i, j)) {
25-
numSets--;
26-
int x = findSet(i), y = findSet(j);
27-
p[y] = x;
28-
setSize[x] += setSize[y];
29-
}
10+
private:
11+
vector<int> p, rank, setSize;
12+
int numSets;
13+
14+
public:
15+
RanklessUnionFind(int N) {
16+
setSize.assign(N, 1);
17+
numSets = N;
18+
rank.assign(N, 0);
19+
p.assign(N, 0);
20+
for (int i = 0; i < N; i++) p[i] = i;
21+
}
22+
intfindSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
23+
boolisSameSet(int i, int j) {returnfindSet(i) == findSet(j); }
24+
voidunionSet(inti, int j) {
25+
if (!isSameSet(i, j)) {
26+
numSets--;
27+
int x = findSet(i), y = findSet(j);
28+
p[y] = x;
29+
setSize[x] += setSize[y];
3030
}
31-
int numDisjointSets() { return numSets; }
32-
int sizeOfSet(int i) { return setSize[findSet(i)]; }
31+
}
32+
int numDisjointSets() { return numSets; }
33+
int sizeOfSet(int i) { return setSize[findSet(i)]; }
3334
};

‎src/data_structures/rmq.cc

Lines changed: 41 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -9,48 +9,45 @@
99
using namespace std;
1010

1111
class RMQ {
12-
private:
13-
vector<long long> tree;
14-
int len;
15-
16-
long long init_tree(vector<long long>& arr, int lo, int hi, int node) {
17-
if (lo == hi) return tree[node] = arr[lo];
18-
int mid = (lo + hi) / 2;
19-
long long left = init_tree(arr, lo, mid, node * 2);
20-
long long right = init_tree(arr, mid + 1, hi, node * 2 + 1);
21-
return tree[node] = min(left, right);
22-
}
23-
24-
long long query(int lo, int hi, int node, int node_lo, int node_hi) {
25-
if (hi < node_lo || node_hi < lo)
26-
return numeric_limits<long long>::max();
27-
if (lo <= node_lo && node_hi <= hi) return tree[node];
28-
int mid = (node_lo + node_hi) / 2;
29-
return min(query(lo, hi, node * 2, node_lo, mid),
30-
query(lo, hi, node * 2 + 1, mid + 1, node_hi));
31-
}
32-
33-
long long update(int idx, int newval, int node, int node_lo, int node_hi) {
34-
if (idx < node_lo || node_hi < idx) return tree[node];
35-
if (node_lo == node_hi) return tree[node] = newval;
36-
int mid = (node_lo + node_hi) / 2;
37-
return tree[node] = min(
38-
update(idx, newval, node * 2, node_lo, mid),
39-
update(idx, newval, node * 2 + 1, mid + 1, node_hi)
40-
);
41-
}
42-
public:
43-
long long query(int lo, int hi) {
44-
return query(lo, hi, 1, 0, len - 1);
45-
}
46-
47-
long long update(int idx, int newval) {
48-
return update(idx, newval, 1, 0, len - 1);
49-
}
50-
51-
RMQ(vector<long long>& arr) {
52-
len = arr.size();
53-
tree.resize(len * 4);
54-
init_tree(arr, 0, len - 1, 1);
55-
}
12+
private:
13+
vector<long long> tree;
14+
int len;
15+
16+
long long init_tree(vector<long long>& arr, int lo, int hi, int node) {
17+
if (lo == hi) return tree[node] = arr[lo];
18+
int mid = (lo + hi) / 2;
19+
long long left = init_tree(arr, lo, mid, node * 2);
20+
long long right = init_tree(arr, mid + 1, hi, node * 2 + 1);
21+
return tree[node] = min(left, right);
22+
}
23+
24+
long long query(int lo, int hi, int node, int node_lo, int node_hi) {
25+
if (hi < node_lo || node_hi < lo) return numeric_limits<long long>::max();
26+
if (lo <= node_lo && node_hi <= hi) return tree[node];
27+
int mid = (node_lo + node_hi) / 2;
28+
return min(query(lo, hi, node * 2, node_lo, mid),
29+
query(lo, hi, node * 2 + 1, mid + 1, node_hi));
30+
}
31+
32+
long long update(int idx, int newval, int node, int node_lo, int node_hi) {
33+
if (idx < node_lo || node_hi < idx) return tree[node];
34+
if (node_lo == node_hi) return tree[node] = newval;
35+
int mid = (node_lo + node_hi) / 2;
36+
return tree[node] =
37+
min(update(idx, newval, node * 2, node_lo, mid),
38+
update(idx, newval, node * 2 + 1, mid + 1, node_hi));
39+
}
40+
41+
public:
42+
long long query(int lo, int hi) { return query(lo, hi, 1, 0, len - 1); }
43+
44+
long long update(int idx, int newval) {
45+
return update(idx, newval, 1, 0, len - 1);
46+
}
47+
48+
RMQ(vector<long long>& arr) {
49+
len = arr.size();
50+
tree.resize(len * 4);
51+
init_tree(arr, 0, len - 1, 1);
52+
}
5653
};

‎src/data_structures/treap_jmbook.cc

Lines changed: 68 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -10,95 +10,95 @@ using namespace std;
1010
typedef int ktype;
1111

1212
struct treap_node {
13-
ktype key;
14-
int priority, size;
15-
treap_node *left, *right;
16-
treap_node(const ktype& _key): key(_key), priority(rand()), size(1),
17-
left(nullptr), right(nullptr) {}
13+
ktype key;
14+
int priority, size;
15+
treap_node *left, *right;
16+
treap_node(const ktype& _key)
17+
: key(_key), priority(rand()), size(1), left(nullptr), right(nullptr) {}
1818

19-
void set_left(treap_node* new_left) {
20-
left = new_left;
21-
calc_size();
22-
}
19+
void set_left(treap_node* new_left) {
20+
left = new_left;
21+
calc_size();
22+
}
2323

24-
void set_right(treap_node* new_right) {
25-
right = new_right;
26-
calc_size();
27-
}
24+
void set_right(treap_node* new_right) {
25+
right = new_right;
26+
calc_size();
27+
}
2828

29-
void calc_size() {
30-
size = 1;
31-
if (left) size += left->size;
32-
if (right) size += right->size;
33-
}
29+
void calc_size() {
30+
size = 1;
31+
if (left) size += left->size;
32+
if (right) size += right->size;
33+
}
3434
};
3535

3636
typedef pair<treap_node*, treap_node*> node_pair;
3737

3838
node_pair split(treap_node* root, ktype key) {
39-
if (root == nullptr) return node_pair(nullptr, nullptr);
40-
if (root->key < key) {
41-
node_pair rs = split(root->right, key);
42-
root->set_right(rs.first);
43-
return node_pair(root, rs.second);
44-
}
45-
node_pair ls = split(root->left, key);
46-
root->set_left(ls.second);
47-
return node_pair(ls.first, root);
39+
if (root == nullptr) return node_pair(nullptr, nullptr);
40+
if (root->key < key) {
41+
node_pair rs = split(root->right, key);
42+
root->set_right(rs.first);
43+
return node_pair(root, rs.second);
44+
}
45+
node_pair ls = split(root->left, key);
46+
root->set_left(ls.second);
47+
return node_pair(ls.first, root);
4848
}
4949

5050
treap_node* insert(treap_node* root, treap_node* node) {
51-
if (root == nullptr) return node;
52-
if (root->priority < node->priority) {
53-
node_pair splitted = split(root, node->key);
54-
node->set_left(splitted.first);
55-
node->set_right(splitted.second);
56-
return node;
57-
} else if (node->key < root->key) {
58-
root->set_left(insert(root->left, node));
59-
} else {
60-
root->set_right(insert(root->right, node));
61-
}
62-
return root;
51+
if (root == nullptr) return node;
52+
if (root->priority < node->priority) {
53+
node_pair splitted = split(root, node->key);
54+
node->set_left(splitted.first);
55+
node->set_right(splitted.second);
56+
return node;
57+
} else if (node->key < root->key) {
58+
root->set_left(insert(root->left, node));
59+
} else {
60+
root->set_right(insert(root->right, node));
61+
}
62+
return root;
6363
}
6464

6565
treap_node* merge(treap_node* a, treap_node* b) {
66-
if (a == nullptr) return b;
67-
if (b == nullptr) return a;
68-
if (a->priority < b->priority) {
69-
b->set_left(merge(a, b->left));
70-
return b;
71-
}
72-
a->set_right(merge(a->right, b));
73-
return a;
66+
if (a == nullptr) return b;
67+
if (b == nullptr) return a;
68+
if (a->priority < b->priority) {
69+
b->set_left(merge(a, b->left));
70+
return b;
71+
}
72+
a->set_right(merge(a->right, b));
73+
return a;
7474
}
7575

7676
treap_node* erase(treap_node* root, ktype key) {
77-
if (root == nullptr) return root;
78-
if (root->key == key) {
79-
treap_node* ret = merge(root->left, root->right);
80-
delete root;
81-
return ret;
82-
}
83-
if (key < root->key) {
84-
root->set_left(erase(root->left, key));
85-
} else {
86-
root->set_right(erase(root->right, key));
87-
}
88-
return root;
77+
if (root == nullptr) return root;
78+
if (root->key == key) {
79+
treap_node* ret = merge(root->left, root->right);
80+
delete root;
81+
return ret;
82+
}
83+
if (key < root->key) {
84+
root->set_left(erase(root->left, key));
85+
} else {
86+
root->set_right(erase(root->right, key));
87+
}
88+
return root;
8989
}
9090

9191
treap_node* kth(treap_node* root, int k) {
92-
int left_size = 0;
93-
if (root->left != nullptr) left_size = root->left->size;
94-
if (k <= left_size) return kth(root->left, k);
95-
if (k == left_size + 1) return root;
96-
return kth(root->right, k - left_size - 1);
92+
int left_size = 0;
93+
if (root->left != nullptr) left_size = root->left->size;
94+
if (k <= left_size) return kth(root->left, k);
95+
if (k == left_size + 1) return root;
96+
return kth(root->right, k - left_size - 1);
9797
}
9898

9999
int less_than(treap_node* root, ktype key) {
100-
if (root == nullptr) return 0;
101-
if (root->key >= key) return less_than(root->left, key);
102-
int ls = (root->left ? root->left->size : 0);
103-
return ls + 1 + less_than(root->right, key);
100+
if (root == nullptr) return 0;
101+
if (root->key >= key) return less_than(root->left, key);
102+
int ls = (root->left ? root->left->size : 0);
103+
return ls + 1 + less_than(root->right, key);
104104
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /