template<typename T>
class Stack {
private:
    T *save;                        // 内存池
    int ed;                         // 末尾指针位置(内存池的下标在区间 [0, ed) 中为合法下标)
public:
    Stack(int n);                   // 构造函数，n 表示内存池大小
    ~Stack();                       // 析构函数，在下发代码中会检测内存是否泄漏
    bool empty();                   // 判断是否为空
    int size();                     // 栈的大小
    void push(T element);           // 向栈顶推入一个元素
    void pop(T element);            // 弹出栈顶的元素
    T top();                        // 返回栈顶的元素
};

template <typename T>
class Hash
{
private:
    int n;

public:
    Hash(int _n) : n(_n) {}
    int operator()(const T &x);
};

template <typename T1, typename T2>
class HashTable
{
private:
    T2 *buckets;
    bool *isFull;
    int size;
    Hash<T1> hash;

public:
    HashTable(int);
    ~HashTable();
    void addItem(const T1 &key, const T2 &value);
    void removeItem(const T1 &key);
    T2 *findByKey(const T1 &key);
};

int Hash<int>::operator()(const int &x)
{
    return x % n;
}

int Hash<std::string>::operator()(const std::string &x)
{
    int ret = 0;
    for (char c : x)
    {
        ret += static_cast<int>(c);
        ret %= n;
    }
    return ret;
}

#include "HashClass.h"
#include "HashFunc.h"

using namespace std;

int main()
{
    int n1, n2, n3, n4, p, q, opr;
    cin >> n1 >> n2 >> n3 >> n4;
    HashTable<int, int> hii(n1);
    HashTable<int, string> his(n2);
    HashTable<string, int> hsi(n3);
    HashTable<string, string> hss(n4);

    int a, b;
    string c, d;
    cin >> p;
    for (int i = 0; i < p; i++)
    {
        cin >> opr;
        switch (opr)
        {
        case 1:
            cin >> a >> b;
            hii.addItem(a, b);
            break;

        case -1:
            cin >> a;
            hii.removeItem(a);
            break;

        case 2:
            cin >> a >> c;
            his.addItem(a, c);
            break;

        case -2:
            cin >> a;
            his.removeItem(a);
            break;

        case 3:
            cin >> c >> a;
            hsi.addItem(c, a);
            break;

        case -3:
            cin >> c;
            hsi.removeItem(c);
            break;

        case 4:
            cin >> c >> d;
            hss.addItem(c, d);
            break;

        case -4:
            cin >> c >> d;
            hss.removeItem(c);
            break;

        default:
            break;
        }
    }

    int *intPointer;
    string *stringPointer;
    cin >> q;
    for (int i = 0; i < q; i++)
    {
        cin >> opr;
        switch (opr)
        {
        case 1:
            cin >> a;
            intPointer = hii.findByKey(a);
            if (intPointer == nullptr)
                cout << "NULL\n";
            else
                cout << *intPointer << "\n";
            break;

        case 2:
            cin >> a;
            stringPointer = his.findByKey(a);
            if (stringPointer == nullptr)
                cout << "NULL\n";
            else
                cout << *stringPointer << "\n";
            break;

        case 3:
            cin >> c;
            intPointer = hsi.findByKey(c);
            if (intPointer == nullptr)
                cout << "NULL\n";
            else
                cout << *intPointer << "\n";
            break;

        case 4:
            cin >> c;
            stringPointer = hss.findByKey(c);
            if (stringPointer == nullptr)
                cout << "NULL\n";
            else
                cout << *stringPointer << "\n";
            break;

        default:
            break;
        }
    }
    return 0;
}

class Game
{
private:
    std::vector<Player *> playerList;
    std::vector<Ore *> oreList;

public:
    Game(int num);
    ~Game();    //TODO
    void run(); //TODO
    friend bool check(Game &);
};

class Ore
{
private:
    bool isMined, shouldBeMined;

public:
    static int cntInstance;

    Ore(bool tag) : isMined(false), shouldBeMined(tag) { cntInstance++; }
    virtual ~Ore() { cntInstance--; };

    friend class Steve;
    friend class Alex;
    friend bool check(Game &);
};

class CoalOre : public Ore
{
public:
    CoalOre(bool tag) : Ore(tag) {}
};

class Player
{
public:
    static int cntInstance;

    Player() { cntInstance++; }
    virtual ~Player() { cntInstance--; };

    virtual void work(Ore *) = 0;
};

class Steve : public Player
{
public:
    void work(Ore *ore) override { ore->isMined = true; }
};

class Alex : public Player
{
public:
    void work(Ore *ore) override { ore->isMined = true; };
};

Game::Game(int num)
{
    srand(time(0));
    for (int i = 0; i < num; i++)
    {
        int tmp = rand();
        if (tmp & 1)
        {
            playerList.push_back(new Steve);
            oreList.push_back(new CoalOre(true));
        }
        else
        {
            playerList.push_back(new Alex);
            oreList.push_back(new CoalOre(false));
        }
    }
}

int Player::cntInstance = 0;
int Ore::cntInstance = 0;

bool check(Game &game)
{
    for (int i = 0; i < game.oreList.size(); i++)
        if (game.oreList[i]->isMined != game.oreList[i]->shouldBeMined)
            return false;
    return true;
}

int main()
{
    int round;
    std::cin >> round;
    for (int i = 0; i < round; i++)
    {
        int n;
        std::cin >> n;
        Game *nowGame = new Game(n);
        nowGame->run();
        if (check(*nowGame))
        {
            delete nowGame;
            if (Player::cntInstance == 0 && Ore::cntInstance == 0)
                std::cout << "ok\n";
        }
    }
    return 0;
}

#include "Rack.hpp"
#include <iostream>


int main(){
    Rack A,B,C,D;
    int n,temp;
    for(int i=0;i<n;i++){//初始给A和B货架添加货物
        cin>>temp;
        if(A<B) A+=temp;//如果A上的货物数量比B少就给A上添加货物
        else B+=temp;
    }
    C=(A,2023,B,2023);//C货架上按照 {A上的货物,标号为2023的货物,B上的货物,标号为2023的货物} 的顺序排列
    cout<<C;//将C货架上的元素按照加入的顺序打印出来，然后让店员摆放
    D=A&&B;//D由A和B**有的元素组成
    cout<<D;
    D=~D;//将C货架上的货物倒序
    D--;//将D货架上最后一个货物卸掉（直接删掉）
    --D;//将D货架上最后一个货物卸掉（直接删掉）
    cout<<D;
    cout<<D[2023]<<endl;//打印出D货架上标号号为2023的货物的个数
    return 0;
}

#include "Drop.h"
#include "DropCollection.h"
#include <iostream>
#include <string>
using namespace std;

inline int str2int(const string& str){
    return atoi(str.data());
}

int main(){
    int n;
    cin >> n;
    DropCollection dc;
    for(int i = 0; i < n; i++){
        cin >> dc; //add a new drop
    }
    int m;
    cin >> m;
    for(int i = 0; i < m; i++){
        string opt, colorA, colorB, locx, locy;
        cin >> opt;
        if (opt == "Move") { //Move a drop to (x, y)
            cin >> colorA >> locx >> locy;
            dc[colorA].moveTo(str2int(locx), str2int(locy));
        } else if (opt == "Merge") { //Merge to different drops
            cin >> colorA >> colorB;
            dc.merge(colorA, colorB);
        } else if (opt == "Ask") { //Ask for a drop's location
            cin >> colorA >> colorB;
            if(dc[colorA] < dc[colorB]){
                cout << dc[colorA] << dc[colorB] << endl;
            } else {
                cout << dc[colorB] << dc[colorA] << endl;
            }
        } else if (opt == "Reduce") { // Reduce the radius of a drop
            cin >> colorA;
            dc[colorA]--;
        } else {
            continue;
        }
    }
    dc.sortDrops(); //Sort drops by x and y
    cout << dc; //print all drops

    return 0;
}

// main.cpp
#include <iostream>
#include "Operator.h"

int n;
int v[10];

void apply(int *a, int n, UnaryOpr* opr) {
    for (int i = 0; i < n; ++i)
        opr->work(a[i]);
}

int find_if(int *a, int n, BoolUnaryOpr* opr) {
    for (int i = 0; i < n; ++i)
        if (opr->work(a[i])) return i;
    return -1;
}

int main() {
    std::cin >> n;
    for (int i = 0; i < n; ++i)
        std::cin >> v[i];

    UnaryOpr* a[3] = {new PlusOpr(2), new MultOpr(3), new NegateOpr()};
    BoolUnaryOpr* b[2] = {new LessOpr(8), new GreaterOpr(3)};

    for (int i = 0; i < 3; ++i) {
        apply(v, n, a[i]);
        for (int j = 0; j < n; ++j)
            std::cout << v[j] << " ";
        std::cout << std::endl;
        delete a[i];
    }
    for (int i = 0; i < 2; ++i) {
        std::cout << find_if(v, n, b[i]) << std::endl;
        delete b[i];
    }

    return 0;
}

#include <iostream>
#include "shareptr.h"
#include "Node.h"

using namespace std;

void test(){
    SharePtr<Node> a(new Node(2));
    {
        SharePtr<Node> b = a;
        SharePtr<Node> c(new Node(3));
        cout << *b << endl;
        b = c;
        cout << *c << endl;
    }
    if(Node::num_createfunc + Node::num_createfunc_default + Node::num_copyfunc + Node::num_movefunc != Node:: num_delfunc + 1){
        cout << "No" << endl;
    }
    cout << *a << endl;

}

int main(){
    test();
    Node::outputResult();
    return 0;
}

#pragma once

template <typename T>
class SharePtr{
private:
    int *_n;
    T *_ptr;
public:
    SharePtr(const SharePtr & t) {
        // Todo
    }

    SharePtr(T * t) : _ptr(t){
        // Todo
    }

    SharePtr<T>&operator=(const SharePtr& t){
        // Todo
    }

    T& operator*() {
        // Todo
    }

    T*operator->(){
        // Todo
    }

    ~SharePtr(){
        // Todo
    }
};

#pragma once
#include <iostream>

void test();

class Node{
private:
	static long long int num_createfunc_default, num_createfunc, num_copyfunc, num_movefunc, num_copyassign, num_moveassign, num_delfunc;
	int val;
public:	
	Node(int v);
	Node();
	~Node();
	Node(const Node &y);
	Node(Node &&y);
	Node& operator=(const Node &y);
	Node& operator=(Node &&y);
	bool operator!=(const Node &y);
	friend std::istream& operator>>(std::istream& in, Node& x);
	friend std::ostream& operator<<(std::ostream& out, const Node& x);
	static void outputResult();
	friend void test();
};

#include "Node.h"

long long int Node::num_createfunc = 0, Node::num_copyfunc = 0, Node::num_movefunc = 0;
long long int Node::num_copyassign = 0, Node::num_moveassign = 0, Node::num_delfunc = 0;
long long int Node::num_createfunc_default = 0;

Node::Node(int v): val(v) {
	num_createfunc++;
}
Node::Node(){
	num_createfunc_default++;
}
Node::~Node() {
	num_delfunc++;
}
Node::Node(const Node &y): val(y.val) {
	num_copyfunc++;
}
Node::Node(Node &&y): val(y.val) {
	y.val = 0;
	num_movefunc++;
}
Node& Node::operator=(const Node &y) {
	val = y.val;
	num_copyassign++;
	return *this;
}
Node& Node::operator=(Node &&y) {
	val = y.val;
	y.val = 0;
	num_moveassign++;
	return *this;
}

bool Node::operator!=(const Node & y){
	return val != y.val;
}

void Node::outputResult() {
	std::cout << Node::num_createfunc_default << " " << Node::num_createfunc << " " << Node::num_copyfunc << " " << Node::num_movefunc << " " << Node::num_copyassign << " " << Node::num_moveassign << " " << Node::num_delfunc << std::endl;
	if (Node::num_createfunc + Node::num_createfunc_default + Node::num_copyfunc + Node::num_movefunc == Node:: num_delfunc){
		std::cout << "YES" << std::endl;
	}	
	else{
		std::cout << "NO" << std::endl;
	}
}

std::istream& operator>>(std::istream& in, Node& x){
	in >> x.val;
	return in;
}
std::ostream& operator<<(std::ostream& out, const Node& x){
	out << x.val;
	return out;
}

#include <iostream>
#include <string>
#include <list>
#include "display.h"
#include "mathExt.h"
#include "point.h"
using namespace std;

#define MAXSIZE 1000

template<typename T>
class MyArray :public Display<MyArray<T>>, public MathExt<MyArray<T>>
{
    T data_[MAXSIZE];
    int n = 0;
public:
    using value_type = T;
    int size() const { return n; }
    T* begin() { return data_; }
    T* end() { return data_ + n; }
    const T* cbegin() const { return data_; }
    const T* cend() const { return data_ + n; }
    void push_back(const T& x) { data_[n++] = x; }
};

template<typename T>
class MyList :public list<T>, public Display<MyList<T>>, public MathExt<MyList<T>>
{
public:
    using list<T>::list;
};

template<typename T>
void test(int m)
{
    T testObj;
    cin >> testObj;
    while (m--)
    {
        string command;
        cin >> command;
        if (command == "cout")
            cout << testObj << endl;
        if (command == "cin")
            cin >> testObj;
        else if (command == "min")
            cout << testObj.min() << endl;
        else if (command == "max")
            cout << testObj.max() << endl;
        else if (command == "sum")
            cout << testObj.sum() << endl;
        else if (command == "double")
            cout << testObj.doubled() << endl;
    }

}

int main()
{
    int n, m;
    cin >> n >> m;
    if (n == 1) test<MyList<int>>(m);
    if (n == 2) test<MyArray<point>>(m);
    return 0;
}

#pragma once
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;

struct point {
    int x = 0, y = 0;
    point() {}
    point(int x_, int y_) :x(x_), y(y_) {}
    int dis() { return x * x + y * y; }
};

bool operator<(point l, point r) { return l.dis() < r.dis(); }
bool operator>(point l, point r) { return l.dis() > r.dis(); }
point operator+(point l, point r) { return point( l.x + r.x,l.y + r.y ); }
point operator*(point l, int t) { return point( l.x*t, l.y*t ); }

istream& operator>> (istream& in, point& p) {
    string s; int x, y;
    in >> s;
    sscanf(s.c_str(), "(%d,%d)", &x, &y);
    p.x = x, p.y = y;
    return in;
}

ostream& operator<< (ostream& out, const point& p) {
    out << "(" << p.x << "," << p.y << ")";
    return out;
}

#include "Pokemon.h"
#include <string>
#include <iostream>
using namespace std;

int main()
{
    Pokemon *players[2];
    for(int i = 0; i < 2; ++i)
    {
        int type, hp, atk;
        cin >> type >> hp >> atk;
        if(type == 1)
            // 宝可梦的名字形如 S(1)、C(0)等，括号中数字i表示player[i]
            players[i] = new Squirtle(hp, atk, "S(" + string(1, '0' + i) + ")");
        if(type == 2)
            players[i] = new Charizard(hp, atk, "C(" + string(1, '0' + i) + ")");
    }
    int rounds;
    cin >> rounds;
    while(rounds--)
    {
        int skill, target;
        cin >> skill >> target;
        players[0]->use_skill(skill, players[target]);
        if(!players[0]->alive() || !players[1]->alive())
            break;
        cin >> skill >> target;
        players[1]->use_skill(skill, players[target]);
        if(!players[0]->alive() || !players[1]->alive())
            break;
    }
    cout << "-----game over-----" << endl;
    cout << players[0]->get_name() << " " << players[0]->get_hp() << " " << players[0]->get_atk() << endl;
    cout << players[1]->get_name() << " " << players[1]->get_hp() << " " << players[1]->get_atk() << endl;
    delete players[0];
    delete players[1];

    return 0;
}

class Pokemon
{
protected:
    int tot_hp, hp, atk;
    string name;
public:
    Pokemon(int hp, int atk, string name);
    Pokemon();
    virtual void use_skill(int idx, Pokemon* target);// 对目标target使用idx号技能
    virtual void hurt(int dmg, Pokemon* from);// 受到来自from的dmg点伤害时的反应
    string get_name();	// 获取宝可梦名字
    bool alive();	 // 宝可梦是否存活
    int get_hp();	 // 获取生命值
    int get_atk();  // 获取攻击力
    ~Pokemon();
};

#include <string>

using namespace std;

using ull = unsigned long long;                             // 使用 unsigned long long 存储数据
const int ullSize = 64;                                     // 长度

// template<size_t size>                                    // 感觉用不上模板类
class Bitset {                                              // 自定义的 bitset 类
    ull *save;                                              // 存储数据的头部指针
    Bitset(int size = 1) {                                  // 为防止做题人搞事情(比如开 size 个 ull, 每次直接访问下标)，给出构造函数的实现
        save = new ull[(size - 1) / ullSize + 1];
    }
    Bitset(string s);                                       // 从 01 串构造
    ~Bitset() {                                             // 给出析构函数的实现
        delete[] save;
    }
    Bitset(const Bitset &a);                                // 拷贝构造，需要实现数组深拷贝
    Bitset(Bitset &&a) = delete;                            // 禁用移动构造
    Bitset &operator=(const Bitset &a);                     // 拷贝赋值，需要实现深拷贝
    Bitset &operator=(Bitset &&a) = delete;                 // 禁用移动赋值
    class Reference {                                       // 用于实现下标操作的 reference 类(比如 a[i]=x )
        Bitset *pointer;                                    // 原 bitset 指针
        int pos;                                            // 下标
        Reference(Bitset *pointer = nullptr, int pos = 0): pointer(pointer), pos(pos) {}        // 给出构造函数
        ~Reference() {}                                     // 给出析构函数(浅拷贝不用 delete )
        Reference &operator=(bool x);                       // 重载赋值函数用于 a[i]=x
        Reference &operator=(Reference r);                  // 重载赋值函数用于 a[i]=b[j]
        bool operator~();                                   // 重载取反运算用于 a[i]=~b[j]
        operator bool();                                    // 重载 bool() 方法用于 x=a[i]
    };
    // 一些 bitset 中的接口，太多可以删掉几个
    bool any();
    bool none();
    int count();
    int size();
    void set();
    void reset();
    string to_string();                                     // 将 bitset 转 01 串
    Reference &operator[](int id);                          // 取下标运算
    // 一些重载的位运算，实现都差不多，太多可以留下两个主要的(比如左移和右移)
    Bitset operator|(Bitset a);
    Bitset &operator|=(Bitset a);
    Bitset operator&(Bitset a);
    Bitset &operator&=(Bitset a);
    Bitset operator~();
    Bitset operator^(Bitset a);
    Bitset &operator^=(Bitset a);
    Bitset operator<<(Bitset a);
    Bitset &operator<<=(Bitset a);
    Bitset operator>>(Bitset a);
    Bitset &operator>>=(Bitset a);
};

#include <iostream>
#include "Json"

using namespace std;

int main()
{
    string s;
    getline(cin, s);
    Json json;
    if(!json.loads(s)) {
        cout << "format error" << endl;
        return 0;
    }
    cout << json << endl;

    return 0;
}

#include <iostream>

class Monomial
{
private:
    int coe; //系数
    int deg; //次数
public:
    Monomial();
    Monomial(int _c, int _d);
    Monomial operator+(const Monomial &x) const;
    Monomial operator-(const Monomial &x) const;
    Monomial operator*(const Monomial &x) const;
    Monomial operator/(const Monomial &x) const;
    int definite_integral(const int a, const int b) const;
    Monomial derive() const;
    int get_val(int x) const;
    //TODO
    // friend std::istream& operator>>(std::istream &in, Monomial &x);
    // friend std::ostream& operator<<(std::ostream &out, const Monomial &x);
};

#include <iostream>

#include "Monomial.h"

using namespace std;

int main()
{
    int n; //单项式个数
    int m; //操作个数
    for (int i = 0; i < n; i++)
    {
        Monomial x, y;
        cin >> x;//输入格式类似于"3x^5","99999997x^100"
        for (int j = 0; j < m; j++)
        {
            int opr, a, b;
            cin >> opr;
            switch (opr)
            {
            case 1:
                cin >> y;
                x = x + y;
                cout << x << "\n";
                break;

            case 2:
                cin >> y;
                x = x - y;
                cout << x << "\n";
                break;

            case 3:
                cin >> y;
                x = x * y;
                cout << x << "\n";
                break;

            case 4:
                cin >> y;
                x = x / y;
                cout << x << "\n";
                break;

            case 5:
                cin >> a >> b;
                cout << x.definite_integral(a, b) << "\n";
                break;

            case 6:
                cout << x.derive() << "\n";//输出格式也类似于"3x^5","99999997x^100"
                break;

            default:
                break;
            }
        }
        int par;
        cout << x.get_val(par) << endl;
    }
    return 0;
}

class Widget {
    string _name;
    public:
    Widget(string name) :_name(name) {}
    string getName() const { return _name; }
    virtual ~Widget() {}
};

class Window {
    list<shared_ptr<Widget>> Widgets;

    public:
    // 返回一个指向名称为name的控件的指针
    shared_ptr<Widget> getPointerByName(string name);

     // 返回一个指向名称为name的控件的引用
    Widget& getElementByName(string name);

    // 将控件w添加到窗口中。如果w的名字已经存在，则不添加w，返回false；否则返回true。
    bool addElement(shared_ptr<Widget> w); 
};

Button b;
b.setClickCommand([]{ cout << "Clicked!"; })

auto c1 = std::make_shared<Checkbox>("c1");
auto c2 = std::make_shared<Checkbox>("c2");
auto b = std::make_shared<Button>("b");
std::list<std::shared_ptr<Checkbox>> l = { c1,c2 };
b->setClickCommand(SelectAll(l));

#include <iostream>
#include <list>
#include <functional>
#include <memory>
#include <algorithm>
#include "window.h"
#include "widget.h"
#include "undo.h"
#include "command.h"
#include "event.h"
using namespace std;

template <typename T>
list<shared_ptr<T>> getLinkedObjects(Window& win) {
    int n;
    cin >> n;
    list<shared_ptr<T>> l;
    while (n--) {
        string s;
        cin >> s;
        l.push_back(dynamic_pointer_cast<T>(win.getPointerByName(s)));
    }
    return l;
}

int main() {
    Window win;
    int n;
    cin >> n;
    while (n--) {
        string command;
        cin >> command;

        if (command == "create") { 
            string type, name; bool flag;
            cin >> type >> name;

            if (type == "button") flag = win.addElement(make_shared<Button>(name));
            else if (type == "checkbox") flag = win.addElement(make_shared<Checkbox>(name));
            else if (type == "radio") flag = win.addElement(make_shared<Radio>(name));

            if (flag) cout << name << " has been created successfully.\n";
            else cout << name << " already exists.\n";
        }
        else if (command == "setclick" || command == "setdoubleclick") {
            string name, type;
            cin >> name >> type;
            
            std::function<void()> fun;
            if (type == "clear") 
                fun = ClearCheckbox(getLinkedObjects<Checkbox>(win));
            else if (type == "selectAll")
                fun = SelectAll(getLinkedObjects<Checkbox>(win));
            else if (type == "submit")
                fun = Submit(getLinkedObjects<Selectbox>(win));

            auto& button = dynamic_cast<Button&>(win.getElementByName(name));
            if(command == "setclick")
                button.setClickCommand(fun);
            else
                button.setDoubleClickCommand(fun);
        }
        else if (command == "click") {
            string name;
            cin >> name;
            auto& clickable_widget = dynamic_cast<Click&>(win.getElementByName(name));
            clickable_widget.click();
        }
        else if (command == "doubleclick") {
            string name;
            cin >> name;
            auto& doubleclickable_widget = dynamic_cast<DoubleClick&>(win.getElementByName(name));
            doubleclickable_widget.doubleClick();
        }
        else if (command == "setgroup") 
            SetGroup(getLinkedObjects<Radio>(win));
        else if (command == "undo") {
            undo();
        }
    }

    return 0;
}

template<class A,class B>bool judge();

#include"judge.h"
#include<iostream>
struct A{};
struct B:A{};
struct C{};
int main(){
    std::cout<<judge<A,B>()<<'\n';
    std::cout<<judge<A,C>()<<'\n';
}

// chess_base.h
#pragma once

enum Color {
    WHITE, BLACK
};

class Chessboard;

class Chess {
protected:
    int x, y;
    Color color;
    Chessboard* board;
public:
    Chess(Chessboard* b, Color c, int x, int y);
    ~Chess();

    // Get properties
    Color getColor();			  // 获取棋子颜色
    virtual void printInfo() = 0; // 打印棋子信息

    // Operations
    // 保证此处传入的所有参数有意义（不会出现越界、“目标位置为自身位置”
    // “目标位置已被占据”、“目标位置无子可吃”等情形）  
    virtual void move(int nxt_x, int nxt_y);			// 直接移动至目标坐标，不做检查
    virtual void attack(int nxt_x, int nxt_y);			// 直接对目标坐标进行吃子，不做检查
    virtual bool isLegalMove(int nxt_x, int nxt_y) = 0;   // 检查能否合法移动至目标坐标
    virtual bool isLegalAttack(int nxt_x, int nxt_y) = 0; // 检查能否合法对目标坐标吃子
};

#pragma once

#include "chess.h"
#include <vector>

class Chessboard {
public:
    static const int size = 8;
    enum {
        FIRST_BLACK_ROW = 1,
        SECOND_BLACK_ROW = 2,
        FIRST_WHITE_ROW = 8,
        SECOND_WHITE_ROW = 7
    };
private:
    Chess* data[size+1][size+1];
    std::vector<Chess*> removed;
    void reset();
    void clear();
public:
    Chessboard();
    Chessboard(const Chessboard& other) = default;
    ~Chessboard();

    Chess* getChess(int x, int y);
    void moveChess(int cur_x, int cur_y, int nxt_x, int nxt_y);
    void placeChess(Chess* chess, int x, int y);
    void removeChess(int x, int y);
};

#include "chess_base.h"
#include "chessboard.h"
#include <iostream>

int main()
{
    Chessboard* chessboard = new Chessboard();
    // 或Chessboard* chessboard = new Chessboard(init);
    int rounds;
    std::cin >> rounds;
    Color cur_color = WHITE, opponent_color = BLACK;
    while (rounds--)
    {
        bool flag = false;
        while(!flag)
        {
            int opr_idx, x, y;
            std::cin >> opr_idx >> x >> y;
            Chess* selected = chessboard->getChess(x, y);
            if (selected == nullptr)
            {
                std::cout << "There's nothing at (" << x << ',' << y << ")." << std::endl;
                continue;
            }

            if (opr_idx == 0)
            {
                selected->printInfo();
                flag = true; // This round ends.
            }
            else
            {
                int nxt_x, nxt_y; // FYI nxt is just a short for "next".
                std::cin >> nxt_x >> nxt_y;
                Chess* dest = chessboard->getChess(nxt_x, nxt_y);

                if (nxt_x == x && nxt_y == y)
                {
                    std::cout << "You are not allowed to move a chess with nothing changed." << std::endl;
                    continue;
                }
                if (selected->getColor() != cur_color)
                {
                    std::cout << "You are not allowed to change your opponent's chesses." << std::endl;
                    continue;
                }

                if (opr_idx == 1)
                {
                    if (dest != nullptr)
                    {
                        std::cout << "You are not allowed to move a chess to an occupied position." << std::endl;
                        continue;
                    }
                    if (selected->isLegalMove(nxt_x, nxt_y))
                    {
                        selected->move(nxt_x, nxt_y);
                        flag = true; // This round ends.
                    }
                    else
                    {
                        std::cout << "You are not allowed to move (" << x << ',' << y << ") to ("
                                  << nxt_x << ',' << nxt_y << ") because of the rules." << std::endl;
                    }
                }
                else if (opr_idx == 2)
                {
                    if (dest == nullptr)
                    {
                        std::cout << "You are not allowed to attack nothing." << std::endl;
                        continue;
                    }
                    if (dest->getColor() == cur_color)
                    {
                        std::cout << "You are not allowed to attack your own chess." << std::endl;
                        continue;
                    }
                    if (selected->isLegalAttack(nxt_x, nxt_y))
                    {
                        selected->attack(nxt_x, nxt_y);
                        flag = true; // This round ends.
                    }
                    else
                    {
                        std::cout << "You are not allowed to use (" << x << ',' << y << ") to attack ("
                                  << nxt_x << ',' << nxt_y << ") because of the rules." << std::endl;
                    }
                }
                else
                    std::cout << "Invalid operation index." << std::endl;
            }
        }
        cur_color = (cur_color == WHITE) ? BLACK : WHITE; // The opponent's turn.
    }

    delete chessboard;
    return 0;
}

MultiDimArray<int,3> arr_1({2,3,4}); // int型的三维数组，尺寸为2*3*4
MultiDimArray<float,1> arr_2({7}); // float型的一维数组，尺寸为7

MultiDimArray<int,3> arr_3({2,3,4});
int a = arr_3[0][1][2];
arr_3[0][1][2] += 1;
const MultiDimArray<int,3> arr_4({1,2,3});
int b = arr_4[0][1][2];
// arr_4[0][1][2] += 1; // 错误，不能更改const数组的元素

MultiDimArray<int,3> arr_5({2,3,4});
MultiDimArray<int,3> arr_6 = arr_5; // 正确，arr_6是arr_5的一个副本
// MultiDimArray<int,4> arr_7 = arr_5; // 错误，维数不同不能复制或移动
MultiDimArray<int,3> arr_8({3,3,3});
arr_8 = std::move(arr_5); // 正确，arr_8尺寸变为2*3*4

// main.cpp
#include "plane.h"
#include "tower.h"
#include <iostream>

int main()
{
    double range;
    std::cin >> range;
    Tower tower(range);

    bool running = true;
    int cmd_num, tick = 0;
    std::cin >> cmd_num;
    while (cmd_num--)
    {
        int cur_time;
        std::cin >> cur_time;
        while (tick < cur_time) // Update the time
        {
            tower.update();
            if (tower.safety_check() == false)
            {
                running = false;
                break;
            }
            ++tick;
        }
        if (!running)
            break;

        int opr;
        char name[10] = {};
        std::cin >> opr >> name;
        if (opr == 0) // New plane
        {
            double dist, angle;
            int alt, spd, head;
            char dest[10] = {};
            std::cin >> dist >> angle >> alt >> spd >> head >> dest;
            tower.addPlane(Plane(name, dist, angle, alt, spd, head));
        }
        else if (opr == 1) // Set altitude
        {
            int alt;
            std::cin >> alt;
            tower[name].setAltitude(alt);
        }
        else if (opr == 2) // Set speed
        {
            int spd;
            std::cin >> spd;
            tower[name].setSpeed(spd);
        }
        else if (opr == 3) // Set heading
        {
            int head;
            std::cin >> head;
            tower[name].setHeading(head);
        }
        else if (opr == 4) // Print a plane's information
        {
            tower[name].printInfo();
        }
        else if (opr == 5) // Print all information
        {
            tower.printAllInfo();
        }
        else
        {
            std::cout << "Invalid operation" << std::endl;
        }
    }

    if (running)
        std::cout << "Safe" << std::endl;
    else
        std::cout << "Game over" << std::endl;
    return 0;
}

class Point {                                // 点类
private:
    int x, y;
public:
    Point(int _x, int _y);                  // 表示二维平面内一点
    ~Point();
    friend istream &operator>>(istream &in, Point &P);
    friend ostream &operator<<(ostream &out, const Point &P);
};

class Shape: public Point {                 // 形状类，抽象基类
public:
    Shape();
    virtual ~Shape() = 0;
    virtual int area() = 0;                 // 表示面积
    virtual int circum() = 0;               // 表示周长
};

class Rectangle: public Shape {             // 矩形类
private:
    Point A, B;                             // 左下角和右上角坐标
public:
    Rectangle(Point _A, Point _B);
    ~Rectangle();
    int area() override;
    int circum() override;
    bool contain(Point P);                  // 判断点是否在矩形中(或边上)
};

class Square: public Rectangle {            // 正方形类
public:
    Square(Point _A, Point _B);
    ~Square();
};

class Circle: public Shape {                // 圆形类
private:
    Point O;                                // 圆心
    int r;                                  // 半径
public:
    int area() override;
    int circum() override;
};

Rectangle *init(Point A, Point B);          // 根据 A 和 B 的位置关系生成一个 Rectangle 或 Square 类指针

string getType(Shape *S);                   // 返回一个字符串表示实际类型

class point {
public:
    int x, y;
    int dis() { return x*x + y*y; }
};

auto discomp = [](point l, point r) { return l.dis() < r.dis(); };
auto xcomp = [](point l, point r) { return l.x < r.x; };
auto ycomp = [](point l, point r) { return l.y < r.y; };

vector<point> v;
// ...
Compare<point> comp = { discomp,xcomp,ycomp };
sort(v.begin(),v.end(),comp);

#include <vector>
#include <algorithm>
#include <string>
#include <iostream>
#include <cstdio>
#include "compare.h"
using namespace std;

class point {
public:
    int x, y;
    int dis() { return x*x + y*y; }
};

istream& operator>> (istream& in, point& p) {
    string s; int x, y;
    in >> s;
    sscanf(s.c_str(), "(%d,%d)", &x, &y);
    p.x = x, p.y = y;
    return in;
}

ostream& operator<< (ostream& out, const point& p) {
    out << "(" << p.x << "," << p.y << ")";
    return out;
}

int main()
{
    auto discomp = [](point x, point y) { return x.dis() < y.dis(); };
    auto xcomp = [](point x, point y) { return x.x < y.x; };
    auto ycomp = [](point x, point y) { return x.y < y.y; };

    Compare<point> comp = { discomp,xcomp,ycomp };

    int n;
    cin >> n;
    vector<point> v;

    while (n--) {
        point p;
        cin >> p;
        v.push_back(p);
    }

    sort(v.begin(), v.end(), comp);

    for (auto p : v)
        cout << p << ' ';
    return 0;
}

#include <vector>
#include <algorithm>
#include <iostream>
#include <string>
#include "compare.h"
using namespace std;

Compare<vector<int>> make_comp(vector<string>,int);

int main()
{
    int m, n, b;
    cin >> m >> n >> b;

    vector<vector<int>> v(m, vector<int>(n));  // 生成m行n列的vector

    vector<string> titles;
    for (int i = 0; i < n; i++) {
        string title;
        cin >> title;
        titles.push_back(title);
    }

    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
            cin >> v[i][j];

    sort(v.begin(), v.end(), make_comp(titles,b));

    for (auto s : titles)
        cout << s << ' ';
    cout << '\n';
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
            cout << v[i][j] << ' ';
        cout << '\n';
    }
    return 0;
}