pat.h

浏览该文件的文档.

#ifndef PROBLEMSCPP_PAT_H
#define PROBLEMSCPP_PAT_H
 
#include <iostream>
#include <queue>
#include <unordered_set>
#include <utility>
#include <vector>
 
using namespace std;
 
namespace pat {
    namespace b {
        namespace b1001 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1002 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1003 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1004 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1005 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1006 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1007 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1008 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1009 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1010 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1011 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1012 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1013 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1014 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1015 {
            struct student {
                string id;
                int morality{};
                int ability{};
                bool operator<(const student &stu) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1015
 
        namespace b1016 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1018 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1019 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1020 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1021 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1022 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1023 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1024 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1025 {
            struct Node {
                string address;
                int data;
                Node *prev = nullptr;
                Node *next = nullptr;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1025
 
        namespace b1026 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1027 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1028 {
            struct Person {
                string name;
                int year{};
                int month{};
                int day{};
                Person() = default;
 
                Person(int year, int month, int day)
                    : year(year), month(month), day(day) {}
 
                bool operator<(const Person &p) const;
            };
 
            bool is_valid(int year, int month, int day);
            int main(istream &cin, ostream &cout);
        }// namespace b1028
 
        namespace b1029 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1030 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1031 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1032 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1033 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1034 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1035 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1036 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1037 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1038 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1039 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1040 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1041 {
            struct student {
                string id;
                int seat1{};
                int seat2{};
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1041
 
        namespace b1042 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1043 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1044 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1045 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1046 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1047 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1048 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1049 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1050 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1051 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1052 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1053 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1054 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1055 {
            struct Person {
                string name;
                int height{};
 
                bool operator<(const Person &p) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1055
 
        namespace b1056 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1057 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1058 {
            struct Problem {
                int score{};
                int num{};
                int correct_num{};
                unordered_set<char> correct_choices;
                int error_count{};
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1058
 
        namespace b1059 {
            bool is_prime(int n);
            int main(istream &cin, ostream &cout);
        }// namespace b1059
 
        namespace b1060 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1061 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1062 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1063 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1064 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1066 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1065 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1067 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1068 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1069 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1070 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1071 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1072 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1073 {
            struct problem {
                int id{};              
                int score{};           
                int noa{};             
                int noca{};            
                unordered_set<char> ca;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1073
 
        namespace b1074 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1075 {
            struct Node {
                string addr;
                int data{};
                string next;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1075
 
        namespace b1076 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1078 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1077 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1079 {
            bool is_palindromic(string str);
            int main(istream &cin, ostream &cout);
        }// namespace b1079
 
        namespace b1080 {
            struct student {
                string id;
                int p        = -1;
                int mid_term = -1;
                int final    = -1;
                int score{};
                [[nodiscard]] int get_score() const;
                bool operator<(const student & /*stu*/) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1080
 
        namespace b1081 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1082 {
            struct player {
                string id;
                int x{};
                int y{};
                [[nodiscard]] int get_dist() const;
                bool operator<(const player & /*p*/) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1082
 
        namespace b1083 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1084 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1085 {
            struct school {
                string id;
                int a_sum = 0;
                int b_sum = 0;
                int t_sum = 0;
                int count = 0;
                school()  = default;
 
                explicit school(string id)
                    : id(std::move(std::move(id))){};
                [[nodiscard]] int get_score() const;
                bool operator<(const school & /*sc*/) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1085
 
        namespace b1086 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1087 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1088 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1089 {
            bool is_true(const vector<int> &vec, int wolf1, int wolf2);
            int main(istream &cin, ostream &cout);
        }// namespace b1089
 
        namespace b1090 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1091 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1092 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1093 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1094 {
            bool is_prime(unsigned int n);
            int main(istream &cin, ostream &cout);
        }// namespace b1094
 
        namespace b1095 {
            struct student {
                string id;
                string date;
                string room;
                char level{};
                int grade{};
            };
 
            struct room {
                string id;
                unordered_set<student *> students;
                int count = 0;
                int sum   = 0;
            };
 
            struct p_stu_comp {
                bool operator()(const student *stu1, const student *stu2) const;
            };
 
            struct room_cnt_comp {
                bool operator()(const pair<string, int> &p1, const pair<string, int> &p2) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1095
 
        namespace b1096 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1097 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1098 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1099 {
            bool is_prime(unsigned int n);
            int main(istream &cin, ostream &cout);
        }// namespace b1099
 
        namespace b1100 {
            struct comp {
                bool operator()(const string &s1, const string &s2) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1100
 
        namespace b1101 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1102 {
            struct paper {
                string id;
                int sale{};
                int price{};
            };
 
            struct comp_sale {
                bool operator()(const paper &p1, const paper &p2) const;
            };
 
            struct comp_total {
                bool operator()(const paper &p1, const paper &p2) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1102
 
        namespace b1103 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1104 {
            bool is_prime(int n);
            void dfs(string str, int current_i, int m, int k, int current_sum, int cnt9, vector<string> &ans);
            int main(istream &cin, ostream &cout);
        }// namespace b1104
 
        namespace b1105 {
            struct node {
                string address;
                unsigned data{};
                string next;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1105
 
        namespace b1106 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1107 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1108 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1109 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace b1110 {
            struct node {
                string address;
                int data{};
                string next;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace b1110
    }// namespace b
 
    namespace a {
        namespace a1003 {
            struct comp {
                bool operator()(const tuple<int, int, int> &a, const tuple<int, int, int> &b) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace a1003
 
        namespace a1004 {
            struct node {
                string id;
                unordered_set<node *> children;
 
                explicit node(string id)
                    : id(std::move(id)) {}
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace a1004
 
        namespace a1005 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1006 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1007 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1008 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1009 {
            int main(istream &cin, ostream &cout);
        }
 
 
        namespace a1013 {
            void dfs(int i, const vector<unordered_set<int>> &g, int occupied, unordered_set<int> &marked);
            int main(istream &cin, ostream &cout);
        }// namespace a1013
 
        namespace a1014 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1015 {
            unsigned reverse(unsigned n, unsigned d);
            bool is_prime(unsigned n);
            unsigned get_num(const string &n, unsigned d);
            int main(istream &cin, ostream &cout);
        }// namespace a1015
 
        namespace a1016 {
            const unsigned M = 31 * 1440 + 10;
 
            struct record {
                string name;
                string time;
                bool online;
                unsigned month;
                unsigned day;
                unsigned hour;
                unsigned minute;
 
                record(string name, const string &time, const string &online);
                bool operator<(const record &r) const;
                [[nodiscard]] unsigned get_minutes() const;
            };
 
            struct customer {
                string name;
                vector<record> records;
 
                customer() = default;
 
                explicit customer(string name)
                    : name(std::move(std::move(name))) {}
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace a1016
 
        namespace a1017 {
            struct customer {
                unsigned id{};
                string arrive_time_str;
                unsigned arrive_time{};
                unsigned p{};
                unsigned start_time{};
                bool operator<(const customer &b) const;
                customer() = default;
                customer(unsigned id, const string &arrive_time_str, unsigned p);
            };
 
            struct customer_comp_p {
                bool operator()(const customer &c1, const customer &c2) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace a1017
 
        namespace a1026 {
            const unsigned INF = 1000000;
 
            struct player {
                string arrival_time_str{};
                unsigned arrival_time = 0;
                unsigned p            = 0;
                unsigned waiting_time = 0;
                unsigned start_time   = 0;
                bool vip              = false;
 
                player() = default;
                player(const string &arrival_time_str, unsigned p, unsigned tag);
                bool operator<(const player &p) const;
                bool operator>(const player &p) const;
            };
 
            struct table {
                unsigned id       = 0;
                unsigned end_time = 0;
 
                bool operator>(const table &p) const;
            };
 
            string timefmt(unsigned t);
 
            void assign(priority_queue<player, vector<player>, greater<player>> &players, priority_queue<table, vector<table>, greater<table>> &tables, vector<player> &vec, vector<unsigned> &table_cnt);
 
            int main(istream &cin, ostream &cout);
        }// namespace a1026
 
        namespace a1018 {
            struct frame {
                vector<unsigned> path;
                unsigned node{};
                int bikes{};
                unsigned len{};
                unsigned start{};
 
                frame() = default;
                frame(vector<unsigned> path, unsigned node, int bikes, unsigned len, unsigned start);
                [[nodiscard]] unsigned get_go() const;
                [[nodiscard]] unsigned get_back() const;
            };
 
            struct frame_cmp {
                bool operator()(const frame &f1, const frame &f2) const;
            };
 
            int main(istream &cin, ostream &cout);
        }// namespace a1018
 
        namespace a1019 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1020 {
            struct TreeNode {
                unsigned key    = 0;
                TreeNode *left  = nullptr;
                TreeNode *right = nullptr;
 
                TreeNode() = default;
 
                TreeNode(unsigned key)
                    : key(key) {}
 
                TreeNode(unsigned key, TreeNode *left, TreeNode *right)
                    : key(key), left(left), right(right) {}
            };
 
            TreeNode *parse(vector<unsigned int> post_order, const vector<unsigned int> &in_order);
 
            int main(istream &cin, ostream &cout);
        }// namespace a1020
 
        namespace a1023 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1024 {
            struct bi {
                vector<unsigned short> vec;
                void reverse();
                [[nodiscard]] bool is_palindromic() const;
                bi operator+(const bi &n2) const;
                bi() = default;
                bi(const string &str);
            };
 
            ostream &operator<<(ostream &os, bi &b);
            int main(istream &cin, ostream &cout);
        }// namespace a1024
 
        namespace a1027 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a1021 {
            int dfs(int father, int nd);
            int main(istream &cin, ostream &cout);
        }// namespace a1021
 
        namespace a7_1 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a7_2 {
            bool isFirstRun(int start, int end);
            int main(istream &cin, ostream &cout);
        }// namespace a7_2
 
        namespace a7_3 {
            int main(istream &cin, ostream &cout);
        }
 
        namespace a7_4 {
            struct Node {
                int val;
                Node *left{};
                Node *right{};
 
                explicit Node(int val)
                    : val(val) {}
            };
 
            Node *genTree(const vector<int> &preorder, const vector<int> &inorder, int pStart, int pEnd, int iStart,
                          int iEnd);
            void postOrder(Node *node, vector<int> &vec);
            int judge(Node *node);
            int main(istream &cin, ostream &cout);
        }// namespace a7_4
    }// namespace a
 
    namespace top {}
}// namespace pat
 
#endif//PROBLEMSCPP_PAT_H