//Training 2 :WATERJUG BFS

1. #include<bits/stdc++.h>
2. using namespace std;
3. //tim uoc chung lon nhat cua a,b
4. int ucln(int a, int b) {
5. while (b != 0) {
6. int temp = b;
7. b = a % b;
8. a = temp;
9. }
10. return a;
11. }
12. int pour(int new_from, int new_to, int c)
13. int from = 0, to = 0;
14. int steps = 0;
15. while (from != c && to != c) {
16. int maxpour = min(from, new_to - to);
17. from -= maxpour;
18. to += maxpour;
19. if (maxpour != 0)
20. steps++;
21. if (from == c || to == c)
22. break;
23. if (from == 0) {
24. from = new_from;
25. steps++;
26. }
27. if (to == new_to) {
28. to = 0;
29. steps++;
30. }
31. }
32. return steps;
33. }
34. int waterjugbfs(int a, int b, int c) {
35. if (a < b) {
36. int temp = a;
37. a = b;
38. b = temp;
39. }
40. if (a < c)
41. return -1;
42. if (c % ucln(a, b) != 0)
43. return -1;
44. return min(pour(a, b, c), pour(b, a, c));
45. }
46. int main() {
47. int a, b, c;
48. int kq;
49.
50. cin >> a >> b >> c;
51. kq = waterjugbfs(a, b, c);
52. cout << kq << endl;
53. return 0;
54. }
//Training 2: Sort int

#include<iostream>

#include<algorithm>

using namespace std;

int main(){

int n;

cin>>n;

int a[n];

for(int i=0; i<n; i++)

cin>>a[i];

sort(a,a+n);

for(int i=0; i<n;i++)

cout<<a[i]<<" ";

return 0;

//Training 2:  PARENTHESES

#include <iostream>

#include <stack>

using namespace std;

bool parentheses(stack<char> stack, string b) {

for (unsigned int i = 0; i < b.length(); i++) {

char c = b[i], ktra;

if ((c == '(') || (c == '[') || (c == '{')) {

stack.push(c);

} else if (c == ')') {

if (stack.empty())

return 0;

else {

ktra = stack.top();

stack.pop();

if (ktra != '(')

return 0;

} else if (c == ']') {

if (stack.empty())

return 0;

else {

ktra = stack.top();

stack.pop();

if (ktra != '[')

return 0;

} else if (c == '}') {

if (stack.empty())

return 0;
 else {

ktra = stack.top();

stack.pop();

if (ktra != '{')

return 0;

return 1;

int main() {

int n, j = 0;

cin >> n;

stack<char> stack;

int a[n];

string b;

while (j < n) {

while (!stack.empty()) {

stack.pop();

b.clear();

cin >> b;

a[j] = parentheses(stack, b);

 j++;

for (int i = 0; i< n; ++i) {

cout << a[i] << endl;

return 0;

//Training 3:TSP

#include<bits/stdc++.h>

using namespace std;

int n, m, cost = 0, minCost = 1000000;

int **A;
bool *a, *b;

stack<int> route;

bool checkinf(int i, int j) {

if (A[i][j] == 1000000)

return 0;

else

return 1;

void TSP(int i) {

for (int j = 2; j < n + 1; j++) {

if ((i != j) && (b[j] && checkinf(i, j))) {

if (minCost < cost + A[i][j])

continue;

b[j] = 0;

route.push(j);

cost += A[i][j];

if (route.size() < n)

TSP(j);

else {

cost += A[j][1];

if (cost < minCost) {

minCost = cost;

}
 cost -= A[j][1];

b[j] = 1;

route.pop();

cost -= A[i][j];

int main() {

scanf("%d %d", &n, &m);

A = new int*[n + 1];

//Khởi tạo mảng 2 chiều vs chi phí max

for (int i = 1; i < n + 1; i++) {

A[i] = new int[n + 1];

for (int j = 1; j < n + 1; j++)

A[i][j] = 1000000;

//thay thế chi phí max cho các con đường dc khai báo

for (int i = 0; i < m; i++) {

int from, to;

scanf("%d", &from);

scanf("%d", &to);

scanf("%d", &A[from][to]);
 }

//Mảng xét các con đường đã đi qua

a = new bool[n + 1];

b = new bool[n + 1];

for (int i = 1; i < n + 1; i++) {

a[i] = 1;

b[i] = 1;

route.push(1);

TSP(1);

printf("%d", minCost);

return 0;

//Training 3:  KNAPSAC

#include <bits/stdc++.h>

using namespace std;

int n, b, g, bk, a[35] = { }, c[35] = { };

long fcur = 0, fopt = 0;

void knapsack(int k) {

for (int i = min(1, bk / a[k]); i >= 0; i--) {

 fcur += i * c[k];

bk -= i * a[k];

if (k == n - 1)

fopt = max(fopt, fcur);

else if (fcur + bk * (float) c[k + 1] / a[k + 1] > fopt)//thêm cận để loại

knapsack(k + 1); //bớt nhánh

fcur -= i * c[k];

bk += i * a[k];

void swap(int i, int j) {

int temp = a[i];

a[i] = a[j];

a[j] = temp;

temp = c[i];

c[i] = c[j];

c[j] = temp;

int main() {

cin >> n >> b;

bk = b;

for (int i = 0; i < n; i++)

cin >> a[i] >> c[i];

 //sắp xếp tăng dần theo trị số cj/aj

for (int i = 0; i < n - 1; i++)

for (int j = i + 1; j < n; j++)

if ((float) c[i] / a[i] < (float) c[j] / a[j])

swap(i, j);

knapsack(0);

cout << fopt;

return 0;

//Training 3: BCA

#include <bits/stdc++.h>

using namespace std;

int m, n, amount, flag = 0, check_opt = 0, _min = 100;

int **A, *a, *b;

vector<int> sorted;

vector<vector<int> > cols;

vector<vector<int> > rows;

bool conflict(int k) {

int i = 1, r = 1;

while (i++ <= amount)

if (b[i] == rows[k].back())
 for (unsigned int j = 0; j < rows[k].size(); j++)

if (rows[k][j] == a[i])

return true;

while (r++ <= amount)

if (a[r] == rows[k].back())

for (unsigned int s = 0; s < rows[k].size(); s++)

if (rows[k][s] == b[r])

return true;

return false;

int conclude() {

unsigned int max = 0;

for (int i = 1; i < m + 1; i++)

if (rows[i].size() > max)

max = rows[i].size();

return max;

void BCA(int k) {

for (unsigned int i = 0; i < cols[sorted[k]].size(); i++) {

rows[cols[sorted[k]][i]].push_back(sorted[k]);

if (conclude() > _min || conflict(cols[sorted[k]][i]))

rows[cols[sorted[k]][i]].pop_back();

else {
 if (k < n - 1) {

BCA(k + 1);

if (check_opt)

return;

rows[cols[sorted[k]][i]].pop_back();

} else {

flag = 1;

_min = _min < conclude() ? _min : conclude();

if (_min == (n + m - 1) / m)

check_opt = 1;

rows[cols[sorted[k]][i]].pop_back();

bool check_exist(int i, int k) {

for (int j = 1; j < A[i][0] + 1; j++)

if (A[i][j] == k)

return true;

return false;

void capacity(int k) {

for (int i = 1; i < m + 1; i++)

 if (check_exist(i, k))

cols[k].push_back(i);

int main() {

int temp;

scanf("%d %d", &m, &n);

A = new int*[m + 1];

for (int i = 0; i < n + 1; i++)

cols.push_back(vector<int>());

for (int i = 0; i < m + 1; i++)

rows.push_back(vector<int>());

for (int i = 1; i < m + 1; i++) {

scanf("%d", &temp);

A[i] = new int[temp + 1];

A[i][0] = temp;

for (int j = 1; j < A[i][0] + 1; j++)

scanf("%d", &A[i][j]);

for (int k = 1; k < n + 1; k++)

capacity(k);

for (int i = 1; i < m + 1; i++)

for (int j = 1; j < n + 1; j++)

if (cols[j].size() == (unsigned) i)
 sorted.push_back(j);

scanf("%d", &amount);

a = new int[amount + 1];

b = new int[amount + 1];

for (int i = 1; i < amount + 1; i++) {

scanf("%d", &a[i]);

scanf("%d", &b[i]);

BCA(0);

if (flag)

printf("%d", _min);

else

printf("-1");

return 0;