// func.h 不论.c还是.cpp文件调用，都不会出错
#ifndef FUNC_H
#define FUNC_H

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

int func(int, int);

#ifdef __cplusplus
}
#endif // __cplusplus

#endif

class Connection {
	unordered_multimap<string, function<void()>> mmap;
public:
	// 按照名称建立映射关系
	void connect(const string& name, const function<void()>& callback) {
		//mmap[name] = callback; ERROR
		mmap.insert({ name, callback });
	}
	void invok(const string& name) {
		auto res = mmap.equal_range(name);
		auto l = res.first, r = res.second;
		while (l != r) {
			l->second();
			++l;
		}
	}
};

// 全局共享的Connection
static Connection con;

class Tom {
public:
	void miaow() {
		cout << "喵" << endl;
		con.invok("mouse");
	}
};

class Jerry {
public:
	Jerry() {
		// 普通类函数的第一个参数是this，所以这里绑定this
		con.connect("mouse", bind(&Jerry::RunAway, this));
	}
	void RunAway() {
		cout << "那只笨又猫来了，快跑！" << endl;
	}
};

int main() {
	// 模拟嵌套层级很深的场景，外部不能直接访问到tom
	struct A {
		struct B {
			struct C {
			private:
				Tom tom;
			public:
				void MiaoMiaoMiao() {
					tom.miaow();
				}
			} c;
			void MiaoMiao() {
				c.MiaoMiaoMiao();
			}
		} b;
		void Miao() {
			b.MiaoMiao();
		}
	} a;

	// 模拟嵌套层级很深的场景，外部不能直接访问到jerry
	struct D {
		struct E {
			struct F {
			private:
				Jerry jerry1, jerry2, jerry3;
			} f;
		} e;
	} d;

	a.Miao();
}

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> g(numCourses);
        vector<int> inDegree(numCourses);
        for (auto& e : prerequisites) {
            g[e[1]].push_back(e[0]);
            ++inDegree[e[0]];
        }
        queue<int> q;
        vector<int> ret;
        for (int i = 0; i < numCourses; ++i)
            if (inDegree[i] == 0) q.push(i);
        while (!q.empty()) {
            int node = q.front(); q.pop();
            ret.push_back(node);
            for (auto e : g[node]) {
                --inDegree[e];
                if (inDegree[e] == 0)
                    q.push(e);
            }
        }
        return ret.size() == numCourses ? ret : vector<int>();
    }
};

class Item {
public:
    int node, skip, dis;
    Item(int a, int b, int c):node(a),skip(b),dis(c){}
    bool operator>(const Item& R) const {
        return this->dis > R.dis;
    }
};
class Solution {
public:
    int INF = 0x3f3f3f3f;
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        vector<vector<pair<int, int>>> g(n);
        for (auto& e : flights) g[e[0]].push_back({ e[1], e[2] });
        vector<int> dist(n, INF);
        dist[src] = 0;
        priority_queue<Item, vector<Item>, greater<Item>> pq;
        pq.emplace(src, 0, 0);
        while (!pq.empty()) {
            auto cur = pq.top(); pq.pop();
            int node = cur.node;
            int dis = cur.dis;
            int skip = cur.skip;
            if (skip > k) continue;
            for (auto& e : g[node]) {
                int w_node = e.first;
                int w_weight = e.second;
                if (dist[w_node] > dist[node] + w_weight) {
                    dist[w_node] = dist[node] + w_weight;
                    pq.emplace(w_node, skip + 1, dist[w_node]);
                }
            }
        }
        return dist[dst];
    }
};

if (a <= b) { // 这里包含等于 可以用全1数组模拟想想
    trr[p++] = arr[l1++];
    ret += (l2-old_l2);
}
else 
    trr[p++] = arr[l2++];