Add more problems

.gdb_history

@@ -1,103 +1,3 @@
-p pref[i - a]
-break 94
-run
-next
-p anms
-p ans
-next
-p i - a
-p pref[i - a]
-p i
-next
-p ansd
-p ans
-next
-p var
-break 127
-ru
-p log
-next
-p log
-p l
-p r
-p r - (1 << log)
-sparse
-p sparse
-break 128
-run
-p sparse
-continue
-run
-p sparse[l][log]
-p l
-p r
-break 128
-run
-break 154
-run
-p seg[0 + fds.size()]
-p segl[0 + fds.size()]
-p segl[1 + fds.size()]
-p segl[1 + fds.size()]
-p segl[2 + fds.size()]
-p segl[3 + fds.size()]
-p segl[4 + fds.size()]
-p segl[5 + fds.size()]
-next
-p i
-p fds[i]
-p sparsequery(i, i)
-p ans
-p i
-next
-p segr[8 + fds.size()]
-p segr[7 + fds.size()]
-p segr[8 + fds.size()]
-p segr[9 + fds.size()]
-break 178
-ru
-p segr
-p segr[5 + fds.size()]
-break 138
-run
-nextr
-next
-pi 
-p i
-p i
-p i
-continue
-necxt
-nexty
-next
-continue
-next
-continue
-next
-next
-p seg[6 + fds.size()]
-break 139
-run
-continue
-next
-p ans
-break 126
-run
-p count
-p n
-break 109
-run
-next
-p ans
-p count
-break 90
-run
-next
-p sum
-next
-p i
-next
-break 110
 run
 p sum
 p count
@@ -254,3 +154,103 @@ p bit
 next
 break 156
 run
+break 97
+run
+p a
+next
+p 
+p n
+next
+p cur
+break 97
+run
+next
+p i
+p cur
+next
+p cur
+next
+p cur
+p ans
+break  98
+ru
+next
+p cur
+p ans
+p a[j]
+p a
+p n / 17
+next
+p cur
+p n / (a[0] * a[1])
+next
+p cur
+next
+next
+p ans
+next
+break 100
+run
+continue
+next
+p cur
+p i
+p n / a[2]
+next
+p cur
+p n / (a[0] * a[2])
+next
+p cur
+p i
+n / (a[1] * a[2])
+p n / (a[1] * a[2])
+next
+p ans
+next
+p cur
+p i
+p n / (a[0] * a[1] * a[2])
+next
+p cur
+next
+p n / a[3]
+next
+p cur
+p i
+p n / (a[0] * a[3])
+p ans
+next
+p ans
+next
+p cur
+p n / (a[1] * a[3])
+next
+p cur
+next
+p cur
+p i
+p n / (a[2] * a[3])
+next
+p cur
+next
+p cur
+next
+pc ur
+next
+p ans
+break 101
+run
+next
+continue
+next
+p cur
+p cur2
+p n / cur2
+p cur
+next
+p cur
+p cur2
+p ans + cur
+p ans2 + n / cur2
+p n / cur2
+p cur

.gitignore

@@ -37,3 +37,5 @@
 
 # Ignore gdb
 .gdb_history
+
+.stfolder

CSES Problem Set/Convex Hull.cpp

@@ -0,0 +1,192 @@
+/* Problem URL: https://cses.fi/problemset/task/2195 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+struct pt {
+    ll x, y;
+    
+    pt() = default;
+    pt(ll x, ll y): x(x), y(y) {}
+    pt(const pt &a): x(a.x), y(a.y) {}
+
+    friend istream &operator >> (istream &is, pt &a) {
+        is >> a.x >> a.y;
+        return is;
+    }
+
+    friend ostream &operator << (ostream &os, pt a) {
+        os << a.x << ' ' << a.y << '\n';
+        return os;
+    }
+
+    ll operator ^ (pt b) {
+        return x * b.y - y * b.x;
+    }
+
+    pt operator - (pt b) {
+        return pt(x - b.x, y - b.y);
+    }
+
+    bool operator < (pt b) {
+        if (x == b.x) {
+            return y < b.y;
+        }
+        return x < b.x;
+    }
+};
+
+ll sarea2(pt a, pt b, pt c) {
+    return (b - a) ^ (c - b);
+}
+
+int ccw(pt a, pt b, pt c)
+{
+    ll ar = sarea2(a, b, c);
+    return (ar > 0) - (ar < 0);
+}
+
+V<pt> convex_hull(V<pt> v)
+{
+    sortv(v);
+    if (v.size() <= 2) {
+        return v;
+    }
+
+    int n = v.size();
+
+    V<pt> ac;
+    V<pt> tmp;
+
+    rep(i, n) {
+        while (ac.size() >= 2 && ccw(ac.end()[-2], ac.end()[-1], v[i]) > 0) {
+            ac.pop_back();
+        }
+        ac.emplace_back(v[i]);
+    }
+
+    for (int i = n - 1; i >= 0; i--) {
+        while (tmp.size() >= 2 && ccw(tmp.end()[-2], tmp.end()[-1], v[i]) > 0) {
+            tmp.pop_back();
+        }
+        tmp.emplace_back(v[i]);
+    }
+
+    ac.pop_back();
+    tmp.pop_back();
+
+    repv(i, tmp) {
+        ac.emplace_back(i);
+    }
+
+    return ac;
+}
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+    V<pt> a(n);
+    cin >> a;
+    auto conv = convex_hull(a);
+    cout << conv.size() << '\n';
+    repv(i, conv) {
+        cout << i.x << ' ' << i.y << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Fibonacci Numbers.cpp

@@ -0,0 +1,151 @@
+/* Problem URL: https://cses.fi/problemset/task/1722 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    ll n;
+    cin >> n;
+
+    if (n == 0) {
+        cout << "0\n";
+        return;
+    }
+
+    const ll mod = 1e9 + 7;
+
+    auto mul = [&](vvl &a, vvl &b) {
+        vvl c(a.size(), vl(b[0].size()));
+
+        rep(i, c.size()) {
+            rep(j, c[i].size()) {
+                rep(k, b.size()) {
+                    c[i][j] = (c[i][j] + a[i][k] * b[k][j] % mod) % mod;
+                }
+            }
+        }
+
+        return c;
+    };
+
+    auto fpow = [&](ll p) {
+        vvl ans = {
+            {0},
+            {1}
+        };
+
+        vvl po = {
+            {0, 1},
+            {1, 1}
+        };
+
+        rep(i, 61) {
+            if ((p >> i) & 1) {
+                ans = mul(po, ans);
+            }
+            po = mul(po, po);
+        }
+
+        return ans;
+    };
+
+    cout << fpow(n - 1)[1] << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Graph Paths I.cpp

@@ -0,0 +1,152 @@
+/* Problem URL: https://cses.fi/problemset/task/1723 */
+ 
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+ 
+using namespace std;
+using namespace __gnu_pbds;
+ 
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+ 
+#define V vector
+ 
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+ 
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+ 
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+ 
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+ 
+using ll = long long;
+ 
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+ 
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+ 
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+ 
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+ 
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+ 
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+ 
+ 
+void pre()
+{
+ 
+}
+ 
+#define TEST 0
+ 
+void solve()
+{
+    int n, m, k;
+    cin >> n >> m >> k;
+ 
+    vvl adj(n, vl(n));
+ 
+    while (m--) {
+        int a, b;
+        cin >> a >> b;
+        adj[a - 1][b - 1]++;
+    }
+ 
+    ll mod = 1e9 + 7;
+ 
+    auto mul = [&](vvl &a, vvl &b) {
+        vvl c(a.size(), vl(b[0].size()));
+ 
+        rep(i, c.size()) {
+            rep(j, c[0].size()) {
+                rep(k, b.size()) {
+                    c[i][j] += a[i][k] * b[k][j];
+                    c[i][j] %= mod;
+                }
+            }
+        }
+ 
+        return c;
+    };
+ 
+    auto fpow = [&]() {
+        vvl ans(n, vl(n));
+        rep(i, n) {
+            ans[i][i] = 1;
+        }
+ 
+        rep(i, 30) {
+            if ((k >> i) & 1) {
+                ans = mul(ans, adj);
+            }
+            adj = mul(adj, adj);
+        }
+ 
+        return ans;
+    };
+ 
+    auto ans = fpow();
+ 
+    cout << ans[0][n - 1] << '\n';
+}
+ 
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+ 
+    pre();
+ 
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Graph Paths II.cpp

@@ -0,0 +1,149 @@
+/* Problem URL: https://cses.fi/problemset/task/1724 */
+ 
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+ 
+using namespace std;
+using namespace __gnu_pbds;
+ 
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+ 
+#define V vector
+ 
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+ 
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+ 
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+ 
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+ 
+using ll = long long;
+ 
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+ 
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+ 
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+ 
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+ 
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+ 
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+ 
+ 
+void pre()
+{
+ 
+}
+ 
+#define TEST 0
+ 
+void solve()
+{
+    int n, m, k;
+    cin >> n >> m >> k;
+ 
+    vvl adj(n, vl(n, OO));
+ 
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        a--, b--;
+        rmin(adj[a][b], (ll)c);
+    }
+ 
+    auto mul = [&](vvl &a, vvl &b) {
+        vvl c(a.size(), vl(b[0].size(), OO));
+ 
+        rep(i, c.size()) {
+            rep(j, c[0].size()) {
+                rep(k, b.size()) {
+                    rmin(c[i][j], a[i][k] + b[k][j]);
+                }
+            }
+        }
+ 
+        return c;
+    };
+ 
+    auto fpow = [&]() {
+        vvl ans(n, vl(n, OO));
+        rep(i, n) {
+            ans[i][i] = 0;
+        }
+ 
+        rep(i, 30) {
+            if ((k >> i) & 1) {
+                ans = mul(ans, adj);
+            }
+            adj = mul(adj, adj);
+        }
+ 
+        return ans;
+    };
+ 
+    ll ans = fpow()[0][n - 1];
+    cout << (ans == OO ? -1 : ans) << '\n';
+}
+ 
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+ 
+    pre();
+ 
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Next Prime.cpp

@@ -0,0 +1,133 @@
+/* Problem URL: https://cses.fi/problemset/task/3396 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll n;
+    cin >> n;
+
+    n++;
+    if (n == 2) {
+        cout << "2\n";
+        return;
+    }
+
+    if (~n & 1) {
+        n++;
+    }
+
+    auto isprime = [&]() {
+        for (ll i = 2; i * i <= n; i++) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    while (!isprime()) {
+        n += 2;
+    }
+
+    cout << n << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Point Location Test.cpp

@@ -0,0 +1,126 @@
+/* Problem URL: https://cses.fi/problemset/task/2189 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll x1, y1, x2, y2, x3, y3;
+    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
+
+    x3 -= x2;
+    y3 -= y2;
+    x2 -= x1;
+    y2 -= y1;
+
+    ll ar = x2 * y3 - y2 * x3;
+
+    if (ar > 0) {
+        cout << "LEFT\n";
+        return;
+    }
+
+    if (ar < 0) {
+        cout << "RIGHT\n";
+        return;
+    }
+
+    cout << "TOUCH\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Polygon Area.cpp

@@ -0,0 +1,122 @@
+/* Problem URL: https://cses.fi/problemset/task/2191 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<pair<ll, ll>> a(n);
+    repv(i, a) {
+        cin >> i.first >> i.second;
+    }
+
+    ll ar = 0;
+    rep(i, n) {
+        auto [x1, y1] = a[i];
+        auto [x2, y2] = a[(i + 1) % n];
+
+        ar += x1 * y2 - y1 * x2;
+    }
+
+    cout << abs(ar) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Prime Multiples.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://cses.fi/problemset/task/2185 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0 
+
+void solve()
+{
+    ll n;
+    int k;
+    cin >> n >> k;
+
+    vl a(k);
+    cin >> a;
+
+    __int128 ans = 0;
+    nrep(i, 1, 1 << k) {
+        long double cur = n;
+        ll cur2 = 1;
+        rep(j, k) {
+            if ((i >> j) & 1) {
+                cur /= a[j];
+                cur2 *= a[j];
+            }
+        }
+
+        if (~__builtin_popcount(i) & 1) {
+            cur = -cur;
+            cur2 = -cur2;
+        }
+
+        ans += (ll)cur;
+    }
+
+    cout << (ll)ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}