acwing.h

浏览该文件的文档.

#ifndef PROBLEMSCPP_ACWING_H
#define PROBLEMSCPP_ACWING_H
 
#include <iostream>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
using namespace std;
 
namespace acwing {
    struct ListNode {
        int val;
        ListNode *next;
 
        explicit ListNode(int x): val(x), next(nullptr) {}
    };
 
    class acwing1 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing4200 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing4201 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing608 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing604 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing606 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing609 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing615 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing616 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing653 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing4203 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing4204 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing2058 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing654 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing605 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing2041 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    namespace acwing2060 {
        class acwing2060 {
        public:
            static int main(istream & /*cin*/, ostream & /*cout*/);
        };
 
        struct point {
            int x;
            int y;
 
            point() = default;
 
            point(int x, int y): x(x), y(y){};
        };
 
        struct pointhash {
            size_t operator()(const point & /*p*/) const;
        };
 
        struct pointequal {
            bool operator()(const point & /*p1*/, const point & /*p2*/) const;
        };
 
        void flood(point /*first*/, bool /*occupy*/[55][55],
                   unordered_set<point, pointhash, pointequal> * /*edge*/,
                   char /*cowhide*/[55][55], int /*n*/, int /*m*/);
    }// namespace acwing2060
 
    namespace acwing2019 {
        const int N = 1000;
 
        struct point {
            int x;
            int y;
            int step;
 
            point(int x, int y, int step): x(x), y(y), step(step){};
        };
 
        int bfs(point /*start*/, int ** /*field*/, int /*max_x*/, int /*max_y*/);
 
        class acwing2019 {
        public:
            static int main(istream & /*cin*/, ostream & /*cout*/);
        };
    }// namespace acwing2019
 
    class acwing611 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing612 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing2014 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing607 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing613 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing610 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing614 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing2005 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
 
        static int dfs(bool stage, char horseshoes[5][5], const bool picked[5][5],
                       int count, int level, int x, int y, int n);
    };
 
    class acwing617 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing618 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing4206 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing4207 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    namespace acwing4208 {
        struct trie_node {
            int val;
            trie_node *father;
            trie_node *nexts[10]{};
 
            trie_node(int val, trie_node *father): val(val), father(father){};
 
            void insert(string str);
 
            void display();
 
            int count();
        };
 
        class acwing4208 {
        public:
            static int main(istream & /*cin*/, ostream & /*cout*/);
        };
    }// namespace acwing4208
 
    class acwing1996 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
 
        static bool cmp(char x, char y);
    };
 
    class acwing656 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing655 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing665 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing657 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing1987 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing660 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing671 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    namespace acwing1978 {
        struct path {
            int a;
            int b;
 
            path(): a(0), b(0){};
 
            path(int a, int b): a(a), b(b){};
            bool operator<(const path &p) const;
        };
 
        class acwing1978 {
        public:
            static int main(istream & /*cin*/, ostream & /*cout*/);
        };
    }// namespace acwing1978
 
    class acwing659 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing662 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing1969 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing664 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing666 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing1960 {
    private:
        int fsm[1 << 16] = {};
        unsigned int n{};
 
    public:
        int main(istream & /*cin*/, ostream & /*cout*/);
        unsigned int get_next(unsigned int status);
        [[nodiscard]] bool *decompress(unsigned int status) const;
        unsigned int compress(const bool * /*bulbs*/) const;
    };
 
    class acwing667 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing668 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing1952 {
    public:
        static int main(istream & /*cin*/, ostream & /*cout*/);
    };
 
    class acwing669 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing672 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1945 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4209 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4210 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4211 {
    public:
        static int main(istream &cin, ostream &cout);
        static unsigned int no2(unsigned long long a);
        static unsigned int no3(unsigned long long a);
        static bool cmp(unsigned long long a, unsigned long long b);
    };
 
    class acwing670 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing633 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1934 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing658 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing661 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    namespace acwing1929 {
        enum direction {
            left,
            right,
            up,
            down
        };
 
        struct step {
            direction d;
            unsigned int x;
            unsigned int y;
 
            step(direction d, unsigned int x, unsigned int y): d(d), x(x), y(y){};
        };
 
        struct step_hash {
            unsigned long operator()(const step & /*s*/) const;
        };
 
        struct step_equal {
            bool operator()(const step & /*main*/, const step & /*tmp*/) const;
        };
 
        class Solution {
        private:
            char mirrors[1000][1000] = {0};
            unsigned int left_map[1000][1000] = {0};
            unsigned int right_map[1000][1000] = {0};
            unsigned int up_map[1000][1000] = {0};
            unsigned int down_map[1000][1000] = {0};
            unsigned short n{};
            unsigned short m{};
 
        public:
            int main(istream &cin, ostream &cout);
            unsigned int count_reflect(direction d, unsigned int x, unsigned int y);
            unsigned (*get_record(direction d))[1000][1000];
        };
 
        direction reflect(direction d, char mirror);
        direction operator!(const direction &d);
    }// namespace acwing1929
 
    class acwing708 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing715 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1922 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing709 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing710 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1913 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing712 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing711 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1904 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing714 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing718 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1884 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4212 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4213 {
    public:
        static int main(istream &cin, ostream &cout);
        static unsigned long long get_min(vector<char> ops,
                                          vector<unsigned long long> vec);
    };
 
    class acwing4214 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing716 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing713 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing721 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing719 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1875 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing720 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing717 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1855 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing724 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing722 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1843 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing723 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing725 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    namespace acwing1826 {
        struct cmprow {
            bool operator()(const pair<unsigned int, unsigned int> &left,
                            const pair<unsigned int, unsigned int> &right) const;
        };
 
        struct cmpcol {
            bool operator()(const pair<unsigned int, unsigned int> &left,
                            const pair<unsigned int, unsigned int> &right) const;
        };
 
        class acwing1826 {
        public:
            static int main(istream &cin, ostream &cout);
        };
    }// namespace acwing1826
 
    class acwing1813 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing726 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing727 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing737 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing740 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1801 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4215 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4216 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4217 {
        vector<char> ops;
        vector<pair<int, int>> forth;
        vector<pair<int, int>> back;
        unsigned int n;
        int a;
        int b;
 
    public:
        int main(istream &cin, ostream &cout);
        [[nodiscard]] bool check(int len) const;
    };
 
    class acwing738 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing741 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1789 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing739 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing742 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1776 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing743 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing744 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1762 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1750 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing745 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing748 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing747 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing746 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1738 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4296 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4297 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4298 {
        int n            = 0;      
        int m            = 0;      
        int *a           = nullptr;
        int *b           = nullptr;
        bool *found      = nullptr;
        bool **connected = nullptr;
        int *match       = nullptr;
 
    public:
        int main(istream &cin, ostream &cout);
        bool find(int i);
    };
 
    class acwing749 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing750 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing751 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing752 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1726 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing753 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing754 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1715 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing755 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing756 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1696 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing760 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing762 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1684 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing761 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing768 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1471 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing763 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing766 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1460 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4299 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4300 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4301 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing765 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing767 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing769 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing764 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1443 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing773 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing770 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing1672 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing772 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing771 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    namespace acwing1660 {
        struct cow {
            int x;
            bool infected;
            bool operator<(const cow & /*c*/) const;
        };
 
        class acwing1660 {
        public:
            static int main(istream &cin, ostream &cout);
        };
    }// namespace acwing1660
 
    class acwing774 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing775 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing3347 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing777 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing776 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4302 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4303 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4304 {
    public:
        static int main(istream &cin, ostream &cout);
        static unsigned int str2int(const string &str);
    };
 
    class acwing778 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing779 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing804 {
    public:
        static int fact(int n);
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing810 {
    public:
        static int abs(int n);
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing805 {
    public:
        static int main(istream &cin, ostream &cout);
        static int max(int x, int y);
    };
 
    class acwing806 {
    public:
        static int main(istream &cin, ostream &cout);
        static double add(double x, double y);
    };
 
    class acwing808 {
    public:
        static int main(istream &cin, ostream &cout);
        static int gcd(int a, int b);
    };
 
    class acwing807 {
    public:
        static int sum(int l, int r);
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing811 {
    public:
        static int main(istream &cin, ostream &cout);
        static void swap(int &x, int &y);
    };
 
    class acwing809 {
    public:
        static int main(istream &cin, ostream &cout);
        static int lcm(int a, int b);
    };
 
    class acwing812 {
    public:
        static int main(istream &cin, ostream &cout);
        static void print(int a[], int size, ostream &cout);
    };
 
    class acwing814 {
    public:
        static int main(istream &cin, ostream &cout);
        static void copy(const int a[], int b[], int size);
    };
 
    class acwing813 {
    public:
        static int main(istream &cin, ostream &cout);
        static void print2D(int a[][100], int row, int col, ostream &cout);
    };
 
    class acwing815 {
    public:
        static int main(istream &cin, ostream &cout);
        static void print(char str[], ostream &cout);
    };
 
    class acwing4305 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4306 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4307 {
    public:
        static int main(istream &cin, ostream &cout);
        static string dfs(int i, bool free, unordered_map<int, int> um, string &b);
    };
 
    class acwing819 {
    public:
        static int main(istream &cin, ostream &cout);
        static int factorial(int n);
    };
 
    class acwing816 {
    public:
        static int main(istream &cin, ostream &cout);
        static void reverse(int a[], int size);
    };
 
    class acwing820 {
    public:
        static int main(istream &cin, ostream &cout);
        static int fibb(int n);
    };
 
    class acwing817 {
    public:
        static int main(istream &cin, ostream &cout);
        static int get_unique_count(int a[], int n);
    };
 
    class acwing818 {
    public:
        static int main(istream &cin, ostream &cout);
        static void sort(int a[], int l, int r);
    };
 
    class acwing821 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing822 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing823 {
    public:
        static int main(istream &cin, ostream &cout);
        static void dfs(vector<int> &vec, set<int> &s, ostream &cout);
    };
 
    namespace acwing21 {
        class Solution {
        public:
            static int Fibonacci(int n);
        };
    }// namespace acwing21
 
    namespace acwing78 {
        class Solution {
        public:
            static string leftRotateString(string str, int n);
        };
    }// namespace acwing78
 
    namespace acwing16 {
        class Solution {
        public:
            static string replaceSpaces(string &str);
        };
    }// namespace acwing16
 
    namespace acwing87 {
        class Solution {
        public:
            static int strToInt(string str);
        };
    }// namespace acwing87
 
    class acwing4308 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4309 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    namespace acwing4310 {
        struct TreeNode {
            int val;
            map<int, TreeNode *> nexts;
 
            explicit TreeNode(int val): val(val) {}
        };
 
        class acwing4310 {
            unordered_map<int, TreeNode *> um;
            unordered_map<int, int> size_tree;
            unordered_map<int, int> position;
 
        public:
            int main(istream &cin, ostream &cout);
            int dfs(vector<int> *vec, TreeNode *node);
        };
    }// namespace acwing4310
 
    namespace acwing84 {
        class Solution {
        public:
            static int getSum(int n);
        };
    };// namespace acwing84
 
    namespace acwing35 {
        class Solution {
        public:
            static ListNode *reverseList(ListNode *head);
        };
    }// namespace acwing35
 
    namespace acwing28 {
        class Solution {
        public:
            static void deleteNode(ListNode *node);
        };
    }// namespace acwing28
 
    namespace acwing66 {
        class Solution {
        public:
            static ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB);
        };
    }// namespace acwing66
 
    namespace acwing36 {
        class Solution {
        public:
            static ListNode *merge(ListNode *l1, ListNode *l2);
        };
    }// namespace acwing36
 
    namespace acwing29 {
        class Solution {
        public:
            static ListNode *deleteDuplication(ListNode *head);
        };
    }// namespace acwing29
 
    namespace acwing67 {
        class Solution {
        public:
            static int getNumberOfK(vector<int> &nums, int k);
        };
    }// namespace acwing67
 
    namespace acwing53 {
        class Solution {
        public:
            static vector<int> getLeastNumbers_Solution(vector<int> input, int k);
        };
    }// namespace acwing53
 
    namespace acwing68 {
        class Solution {
        public:
            static int getMissingNumber(vector<int> &nums);
        };
    }// namespace acwing68
 
    namespace acwing75 {
        class Solution {
        public:
            static vector<int> findNumbersWithSum(vector<int> &nums, int target);
        };
    }// namespace acwing75
 
    namespace acwing32 {
        class Solution {
        public:
            static void reOrderArray(vector<int> &array);
        };
    }// namespace acwing32
 
    namespace acwing51 {
        class Solution {
        public:
            static vector<vector<int>> permutation(vector<int> &nums);
            static void dfs(const vector<int> &vec, vector<int> nums,
                            set<vector<int>> &s);
        };
    }// namespace acwing51
 
    namespace acwing17 {
        class Solution {
        public:
            static vector<int> printListReversingly(ListNode *head);
        };
    }// namespace acwing17
 
    namespace acwing26 {
        class Solution {
        public:
            static int NumberOf1(int n);
        };
    }// namespace acwing26
 
    namespace acwing20 {
        class MyQueue {
        private:
            vector<int> main;
            vector<int> tmp;
 
        public:
            MyQueue();
            void push(int x);
            int pop();
            int peek();
            [[nodiscard]] bool empty() const;
        };
    }// namespace acwing20
 
    class acwing862 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing4311 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing3412 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    class acwing3346 {
    public:
        static int main(istream &cin, ostream &cout);
    };
 
    namespace acwing3358 {
        int main(istream &cin, ostream &cout);
    };
 
    namespace acwing3370 {
        struct cow {
            string name;
            int val;
            int zodiac;
            vector<cow *> previous;
            vector<cow *> next;
 
            cow(string name, int val, int zodiac);
        };
 
        int main(istream &cin, ostream &cout);
        int dfs(cow *c);
    }// namespace acwing3370
 
    namespace acwing3745 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1459 {
        int main(istream &cin, ostream &cout);
    }// namespace acwing1459
 
    namespace acwing1442 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing4314 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing4315 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1671 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1659 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1714 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1695 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1683 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing4318 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing4319 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1470 {
        struct status {
            int len;
            pair<int, int> current;
            pair<int, int> target;
            bool operator<(const status &s) const;
            [[nodiscard]] int get_weight() const;
 
            status(int len, pair<int, int> current, pair<int, int> target)
                : len(len), current(std::move(current)), target(std::move(target)) {}
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing1470
 
    namespace acwing1761 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1749 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1737 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1725 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing4394 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1812 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1800 {
        int main(istream &cin, ostream &cout);
    }// namespace acwing1800
 
    namespace acwing1788 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1775 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing785 {
        void qs(vector<int> &vec, int l, int r);
        int main(istream &cin, ostream &cout);
    }// namespace acwing785
 
    namespace acwing788 {
        void ms(vector<int> &vec, int l, int r);
        int main(istream &cin, ostream &cout);
    }// namespace acwing788
 
    namespace acwing789 {
        unsigned bfl(const vector<unsigned> &vec, unsigned target);
        unsigned bfr(const vector<unsigned> &vec, unsigned target);
        int main(istream &cin, ostream &cout);
    }// namespace acwing789
 
    namespace acwing1866 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1854 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing4397 {
        bool cmp(const pair<int, int> &a, const pair<int, int> &b);
        int main(istream &cin, ostream &cout);
    }// namespace acwing4397
 
    namespace acwing4398 {
        struct TrieNode {
            char ch;
            unordered_map<char, TrieNode *> nexts = unordered_map<char, TrieNode *>();
            unordered_set<string *> origin        = unordered_set<string *>();
 
            explicit TrieNode(char ch): ch(ch) {}
 
            void insert(const string &str, int start, string *origin);
            [[nodiscard]] TrieNode *search(const string &str, int start);
            ~TrieNode();
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing4398
 
    namespace acwing1842 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1824 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing800 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing2816 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1902 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing3302 {
        int main(istream &cin, ostream &cout);
    }// namespace acwing3302
 
    namespace acwing831 {
        vector<int> get_next(const string &str);
        int main(istream &cin, ostream &cout);
    }// namespace acwing831
 
    namespace acwing1892 {
        int main(istream &cin, ostream &cout);
    }// namespace acwing1892
 
    namespace acwing1883 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing1995 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing143 {
        struct TrieNode {
            TrieNode *next[2] = {nullptr, nullptr};
            int val{};
            void insert(const string &str, int i);
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing143
 
    namespace acwing837 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing240 {
        struct UnionFind {
            explicit UnionFind(int n);
            vector<int> parent;
            vector<int> dist;
            int find(int x);
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing240
 
    namespace acwing845 {
        struct hash {
            unsigned int operator()(const array<array<char, 3>, 3> &g) const;
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing845
 
    namespace acwing849 {
        struct comp {
            bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) const;
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing849
 
    namespace acwing853 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing851 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing852 {
        bool spfa(const vector<unordered_map<int, int>> &g, int m, int n);
        int main(istream &cin, ostream &cout);
    }// namespace acwing852
 
    namespace acwing854 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing858 {
        int main(istream &cin, ostream &cout);
    }
 
    namespace acwing859 {
        struct edge {
            int u;
            int v;
            int w;
 
            bool operator<(const edge &e) const;
        };
 
        int main(istream &cin, ostream &cout);
    }// namespace acwing859
 
    namespace acwing860 {
        bool dfs(vector<unordered_set<int>> &g, int node, vector<int> &color, int c);
        int main(istream &cin, ostream &cout);
    }// namespace acwing860
 
    namespace acwing861 {
        bool find(vector<unordered_set<int>> &g, int x, vector<bool> &st,
                  vector<int> &match);
        int main(istream &cin, ostream &cout);
    }// namespace acwing861
 
    namespace acwing3373 {
        int main(istream &cin, ostream &cout);
    }// namespace acwing3373
}// namespace acwing
#endif// PROBLEMSCPP_ACWING_H