C++ queue::emplace方法代码示例

	inline bool bfs() {
		for (size_t left = 1; left <= n; left++) {
			if (pairL[left] == NIL) {
				level[left] = 0;
				que.emplace(left);
			}
			else level[left] = INF;
		}
		level[NIL] = INF;

		while (que.size()) {
			size_t left = que.front();
			que.pop();

			if (level[left] >= level[NIL]) continue;

			for (size_t right : graph->at(left)) {
				size_t prevPair = pairR[right];

				if (level[prevPair] == INF) {
					level[prevPair] = level[left] + 1;
					que.emplace(prevPair);
				}
			}
		}

		return level[NIL] != INF;
	}

void getParameterLists(const string &inputFileName,
                       queue<ParameterList> &problems,
                       queue<ParameterList> &comparisons,
                       const RCP<const Teuchos::Comm<int> > & comm)
{
  int rank = comm->getRank();
  // return a parameter list of problem definitions
  // and a parameter list for solution comparisons
  Teuchos::FileInputSource inputSource(inputFileName);
  if(rank == 0) cout << "input file source: " << inputFileName << endl;
  XMLObject xmlInput;
  
  // Try to get xmlObject from inputfile
  try{
    xmlInput = inputSource.getObject();
  }
  catch(exception &e)
  {
    EXC_ERRMSG("Test Driver error: reading", e); // error reading input
  }
  
  // get the parameter lists for each model
  for(int i = 0; i < xmlInput.numChildren(); i++)
  {
    ParameterList plist;
    xmlToModelPList(xmlInput.getChild(i), plist);
    if(plist.name() == "Comparison") comparisons.emplace(plist);
    else problems.emplace(plist);
  }
}

 void enqueue(const T &x) {
   Q.emplace(x);
   while (D.empty() == false && D.back() < x) {
     D.pop_back();
   }
   D.emplace_back(x);
 }

    void run() {
        while (1) {

            unique_lock<mutex> sqlLock(sqlMutex);
            cout << this_thread::get_id() << ": waiting until sqlQueue is NOT empty " << sqlQueue.size() << endl;
            sqlCond.wait(sqlLock, []{ return !sqlQueue.empty(); } );
            string sql = sqlQueue.front();
            sqlQueue.pop();
            sqlLock.unlock();

            cout << this_thread::get_id() << ": working on sql=" << sql << endl;
            string res = "";
            if (0 != exec(sql, res)) {
                cout << this_thread::get_id() << ": failed with error=" << m_error << endl;
                res = "failed with error="+m_error;
            }
            
            unique_lock<mutex> resultLock(resultMutex);
            cout << this_thread::get_id() << ": setting result to resultQueue, now size=" << resultQueue.size() << endl;
            resultQueue.emplace(res);
            resultLock.unlock();
            resultCond.notify_one();

        }
    }

int main() {
	scanf("%d %d\n", &l, &w);
	for (int i = 0; i < l; i++) {
		for (int j = 0; j < w; j++) map[i][j] = getchar() == 'L';
		getchar();
	}

	int m = 0, t;
	for (int i = 0; i < l; i++) {
		for (int j = 0; j < w; j++) {
			if (map[i][j]) {
				t = 0;
				q.emplace(i, j);

				for (int k = 0; k < l; k++) fill_n(visit[k], w, false);

				size_t len = q.size();
				while (!q.empty()) {
					bool check = false;
					while (len--) {
						auto t = q.front();
						q.pop();

						int &y = t.first, &x = t.second;
						if (y < 0 || y > l || x > w || x < 0 || !map[y][x] || visit[y][x]) continue;
						check = visit[y][x] = true;

						q.emplace(y - 1, x);
						q.emplace(y + 1, x);
						q.emplace(y, x + 1);
						q.emplace(y, x - 1);
					}
					len = q.size();
					if (check) t++;
				}
				m = max(t, m);
			}
		}
	}
	printf("%d", m - 1);
}

	static void checkSucc(seq_len_t idx, const sequence_in_t & seq,
			const vector<unique_ptr<TestNodeC>>& cs, queue<seq_len_t>& newlyConfirmed) {
		seq_len_t aIdx = idx;
		for (auto input : seq) {
			aIdx++;
			if ((aIdx == cs.size()) || (cs[aIdx]->input != input)) return;
		}
		if (!cs[aIdx]->confirmed) {
			cs[aIdx]->confirmed = true;
			newlyConfirmed.emplace(aIdx);
		}
	}

void paralleGet(const vector<string>& sqlVec, vector<string>& resVec)
{
    unique_lock<mutex> sqlLock(sqlMutex);
    int size = sqlVec.size();
    for (auto it : sqlVec) {
        sqlQueue.emplace(it);
    }
    sqlLock.unlock();
    sqlCond.notify_all();

    unique_lock<mutex> resultLock(resultMutex);
    // while (resultQueue.size() != size) {
    //     resultCond.wait(resultLock);
    // }
    resultCond.wait(resultLock, [&] { return resultQueue.size() == size; } ); // 需要使用 & 才可以把局部变量 size 传入

    while (resultQueue.size()) {
        resVec.emplace_back(resultQueue.front());
        resultQueue.pop();
    }
    resultLock.unlock();

}

	static void processNewlyConfirmed(const vector<unique_ptr<TestNodeC>>& cs, queue<seq_len_t>& newlyConfirmed,
		vector<vector<bool>>& verifiedTransition, vector<input_t>& verifiedState, vector<shared_ptr<ver_seq_t>>& verSeq,
		vector<vector<seq_len_t>>& confirmedNodes, seq_len_t& counter, seq_len_t& currIdx, seq_len_t& lastConfIdx) {
		while (!newlyConfirmed.empty()) {
			auto idx = newlyConfirmed.front();
			if ((idx > lastConfIdx) && (idx <= currIdx)) lastConfIdx = idx;
			confirmedNodes[cs[idx]->state].push_back(idx);
			auto vs = verSeq[cs[idx]->state];
			for (++idx; idx < cs.size(); idx++) {
				auto nextVs = findNext(vs, cs[idx]->input);
				if (!nextVs) {
					for (; idx < cs.size(); idx++) {
						if (cs[idx]->confirmed) {
							update(newlyConfirmed.front(), cs, newlyConfirmed, verifiedTransition, verifiedState,
								verSeq, confirmedNodes, counter);
							break;
						}
					}
					break;
				}
				if (!nextVs->child) {// leaf
					if (!cs[idx]->confirmed) {
						cs[idx]->confirmed = true;
						newlyConfirmed.emplace(idx);
					}
					break;
				}
				if (cs[idx]->confirmed) {
					update(newlyConfirmed.front(), cs, newlyConfirmed, verifiedTransition, verifiedState, verSeq, confirmedNodes, counter);
					break;
				}
				vs = nextVs;
			}
			newlyConfirmed.pop();
		}
	}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	cin >> n >> m >> x >> y;
	while (m--)
	{
		int u, v;
		char ch;
		cin >> u >> ch >> v;
		adj[u].push_back(v);
		adj[v].push_back(u);
		price[{u, v}] = price[{v, u}] = ch;
	}

	q.emplace(x, x, 0);
	memset(vis, -1, sizeof vis);
	while (!q.empty())
	{
		int u = q.front().u, v = q.front().v, l = q.front().l;
		q.pop();
		if (vis[u] != -1)
		{
			if (l == vis[u] && u != v)
				from[u].push_back(v);
			continue;
		}
		vis[u] = l;
		if (u != v)
			from[u].push_back(v);
		for (auto nu : adj[u]) if (nu - v)
		{
			q.emplace(nu, u, l + 1);
		}
	}

	queue<int> temp;
	temp.push(y);
	dag[y] = true;
	while (!temp.empty())
	{
		int u = temp.front();
		temp.pop();
		for (auto nu : from[u]) if (!dag[nu])
		{
			temp.push(nu);
			dag[nu] = true;
		}
	}

	vector<int> cur;
	cur.push_back(x);
	memset(f, -1, sizeof f);
	while (!cur.empty())
	{
		int mn = inf;
		bool flag = false;
		for (auto u : cur)
		{
			if (u == y)
			{
				flag = true;
				break;
			}
			done[u] = true;
			for (auto v : adj[u]) if (dag[v] && !done[v])
				mn = min(mn, price[{u, v}]);
		}
		if (flag)
			break;
		vector<int> temp;
		for (auto u : cur)
		{
			for (auto v : adj[u]) if (dag[v] && !done[v] && price[{u, v}] == mn)
			{
				temp.push_back(v);
				f[v] = u;
				done[v] = true;
			}
		}
		cur = temp;
	}

	int u = y;
	string ans;
	while (u != x && u != -1)
	{
		ans += price[{f[u], u}];
		u = f[u];
	}
	reverse(ans.begin(), ans.end());
	cout << ans << '\n';
}