void Median::insert(int value)
{
size_t l = maxHeap1.size();
size_t m = minHeap2.size();
if (l - m == 0) {
if (l != 0 && value > maxHeap1.top()) {
minHeap2.push(value);
} else {
maxHeap1.push(value);
}
} else if (labs(l - m) == 1) {
if (l > m) {
if (maxHeap1.top() > value) {
int r = maxHeap1.top();
maxHeap1.pop();
minHeap2.push(r);
maxHeap1.push(value);
} else {
minHeap2.push(value);
}
} else {
if (minHeap2.top() < value) {
int r = minHeap2.top();
minHeap2.pop();
maxHeap1.push(r);
minHeap2.push(value);
} else {
maxHeap1.push(value);
}
}
}
}
int main(void)
{
scanf("%u %u", &words, &maxLength);
for(unsigned int w = 0; w < words; ++ w)
{
scanf("%s", word);
sWord[w] = std::string(word);
que.push(sWord[w]);
}
while(!que.empty() && que.top().length() <= maxLength)
{
act = que.top();
que.pop();
if(isPalindrome(act))
{
++ result;
if(result == 835454957)
result = 0;
}
for(unsigned int w = 0; w < words; ++ w)
que.push(act + " " + sWord[w]);
}
printf("%u\n", result);
return 0;
}
int main(void)
{
while(scanf("%d", &numbers) != -1 && numbers)
{
result = 0;
for(int n = 0; n < numbers; ++ n)
{
scanf("%d", &number);
que.push(number);
}
while(que.size() > 1)
{
int first = que.top(); que.pop();
int second = que.top(); que.pop();
que.push(first + second);
result += first + second;
}
que.pop();
printf("%lld\n", result);
}
return 0;
}
// this
inline void scheduler_loop() {
std::unique_ptr<Priority> pCurrentPrty;
for (;;) {
std::unique_lock<std::mutex> lock(queue_mutex);
// wait for some task to get queued or for the atomic
// isActive flag to become inactive
condition.wait(lock, [this, &pCurrentPrty] {
if (!mTasks.empty() &&
pCurrentPrty && pCurrentPrty->getPriorityStr() !=
mTasks.top().getPriority().getPriorityStr() &&
pCurrentPrty->getPriorityStr().length() !=
mTasks.top().getPriority().getPriorityStr().length()) {
std::cout << "priority change" << std::endl;
}
return (!mTasks.empty() || !isActive.load());
});
// only exit when no more tasks on the queue
if (!isActive.load() && mTasks.empty()) {
return;
}
// update the top priority job that is currently running
pCurrentPrty = std::make_unique<Priority>(mTasks.top().getPriority());
// move next task off the priority queue
auto nextTask(std::move(mTasks.top()));
pCurrentPrty = std::make_unique<Priority>(nextTask.getPriority());
// queue housekeeping
mTasks.pop();
// release the lock allowing new entries to be queued
lock.unlock();
// execute the task forwarding stored arguments with the call
// this is the magic that works inside a thread pool
// _Ret operator()(_Types... _Args) const
nextTask();
}
}
// preferences should be a member
wns::scheduler::ConnectionID
ProportionalFair::getNextConnection(SchedulerStatePtr schedulerState,
std::priority_queue<UserPreference> preferences)
{
wns::scheduler::ConnectionID next = -1;
while (!preferences.empty())
{
int priority = schedulerState->currentState->getCurrentPriority();
const float preference = preferences.top().first;
const UserID user = preferences.top().second;
MESSAGE_SINGLE(NORMAL, logger, "Selected user="******"Selected connection with CID="<<next);
return next;
}
preferences.pop();
}
return next;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &t);
adj[a].push_back(std::make_pair(b, t));
adj[b].push_back(std::make_pair(a, t));
}
dist[0] = 0;
q.push(std::make_pair(0, 0));
for (int i = 1; i < n; i++) {
dist[i] = 0x3f3f3f3f;
q.push(std::make_pair(-dist[i], i));
}
while (!q.empty()) {
std::tie(cur_dist, cur_index) = q.top(); q.pop();
cur_dist *= -1;
vis[cur_index] = 1;
for (std::pair<int, int> p : adj[cur_index]) {
if (!vis[p.first]) {
const int alt = cur_dist + p.second;
if (alt < dist[p.first]) {
dist[p.first] = alt;
q.push(std::make_pair(-alt, p.first));
}
}
}
}
dist2[0] = 0;
q.push(std::make_pair(0, n - 1));
for (int i = 0; i < n - 1; i++) {
dist2[i] = 0x3f3f3f3f;
q.push(std::make_pair(-dist2[i], i));
}
while (!q.empty()) {
std::tie(cur_dist, cur_index) = q.top(); q.pop();
cur_dist *= -1;
vis2[cur_index] = 1;
for (std::pair<int, int> p : adj[cur_index]) {
if (!vis2[p.first]) {
const int alt = cur_dist + p.second;
if (alt < dist2[p.first]) {
dist2[p.first] = alt;
q.push(std::make_pair(-alt, p.first));
}
}
}
}
for (int i = 0; i < n; i++) {
ans = std::max(ans, dist[i] + dist2[i]);
}
printf("%d\n", ans);
}
double getMedian(const std::priority_queue<double, std::vector<double>, std::greater<double> >& m,
const std::priority_queue<double>& M){
if(m.size() > M.size()) // There are an odd number of observations
return m.top();
else if(M.size() > m.size()) // There are an odd number of observations
return M.top();
else // There are an even number of obersations
return (m.top()+M.top())/2;
}
void update_world(double frame_start,double tot_time){
double frame_stop = current_time+tot_time;
double dt;
ObjectPair* pair;
if(pairs.size() > 0 ){
while( pairs.top()->wake_up < frame_stop){
pair = pairs.top();
// cout << "Popped pair: " << pair->id << ".\n";
dt = pair->wake_up - pair->sim_time();
if( dt < min_dt)
dt=min_dt;
//the object will be simulated this far when the loo has ended
pairs.pop();
pair->simulate(dt);
if(pair->has_collided()){
Collision col = pair->get_collision();
pair->collide(col);
pair->simulate(min_dt);
while(pair->has_collided()){
pair->simulate(min_dt);
}
}
// cout << "Before -- Pair: " << pair->id << " Wake_up: " << pair->wake_up << ".\n";
pair->calc_wake_up();
// cout << "After -- Pair: " << pair->id << " Wake_up: " << pair->wake_up << ".\n";
pairs.push(pair);// bara om de inte har dött
}
}
for(int i = 0; i < objects.size(); i++){
dt = frame_stop - objects[i]->sim_time;
if(dt > 0)
objects[i]->simulate(dt);
}
}
void dijkstra() {
std::fill(d + 1, d + n + 1, INF);
for (int i = 1; i <= n; i++) {
if (!w[i]) continue;
heap.push((Heapnode){d[i] = 0, i});
}
while (!heap.empty()) {
Heapnode top = heap.top(); heap.pop();
if (v[top.node]) continue;
v[top.node] = true;
for (int i = h[top.node]; i; i = e[i].next)
if (!v[e[i].node] && d[e[i].node] > top.dist + e[i].dist) {
d[e[i].node] = top.dist + e[i].dist;
p[e[i].node] = top.node;
heap.push((Heapnode){d[e[i].node], e[i].node});
}
}
s = 0;
for (int i = 1, cnt = 0; i <= n; i++) {
if (!w[i]) continue;
c[i] = ++s;
}
for (int i = 1; i <= n; i++) {
if (w[i]) continue;
fa[getfa(i)] = getfa(p[i]);
}
for (int i = 1; i <= n; i++) {
if (w[i]) continue;
c[i] = c[getfa(i)];
}
}
int expand()
{
Nodes node= nodes.top();
if(nodes.size()==0)
{
cout<<"error";
getch();
return 0;
}
nodes.pop();
if(visited[node.node]==1)
return 0;
else
visited[node.node]=1;
if(node.node==end)
{
cout<<"Minimum delay from source to destination device:"<<node.cost;
return 1;
}
else
{
for(int j=0;j<n;j++)
{
if(a[j][node.node]!=0)
{
nodes.push(Nodes(j,node.cost+a[j][node.node]));
}
}
}
return 0;
}
Node::Ptr peek() const
{
if (queue.empty())
return Node::Ptr();
Node::Ptr result = queue.top();
return result;
}
PLUGIN_EXPORT int PLUGIN_CALL
AmxUnload(AMX * amx)
{
std::priority_queue<struct timer_s *, std::deque<struct timer_s *>, TimerCompare>
cleaned;
// Destroy all the timers for this mode.
while (!gTimers.empty())
{
struct timer_s *
next = gTimers.top();
gTimers.pop();
if (next->amx == amx)
{
// Ending, remove from the map also.
gHandles.erase(next->id);
}
else
{
// Not ending, leave it be.
cleaned.push(next);
}
}
gTimers = cleaned;
for (int i = 0; i != 17; ++i)
{
if (gAMXFiles[i] == amx)
{
gAMXFiles[i] = 0;
break;
}
}
return AMX_ERR_NONE;
}
/**
* Recursively search the decision tree over the acting agents.
*
* TODO: I want a custom priority queue here, which can be quickly reset and copied
*/
float doSearch(
WorldStateInterface* progressiveWorldState,
std::priority_queue<AgentStateInterface*> agentQueue,
int depth) {
if (depth <= 0) {
// TODO: evaluate the state
return 0;
}
WorldStateInterface::SnapshotInterface* snapshot = progressiveWorldState->takeSnapshot();
AgentStateInterface* actingAgent = agentQueue.top();
agentQueue.pop();
std::list<ActionInterface*> actions = actingAgent->getPossibleActions();
float best = 0, score = 0;
for (std::list<ActionInterface*>::iterator iter = actions.begin(); iter != actions.end(); ++iter) {
(*iter)->doAction();
score = doSearch(progressiveWorldState, agentQueue, depth - 1);
progressiveWorldState->restoreShapshot(snapshot);
if (score > best) {
best = score;
}
}
return best;
}
/**
* decode next alignment
*
* @param algn reference to alignment object to be filled
* @return true iff next alignment could be read, false when no more alignments are available
**/
bool readAlignment(libmaus::bambam::BamAlignment & algn)
{
if ( Q.empty() )
return false;
uint64_t const t = Q.top();
Q.pop();
libmaus::bambam::BamAlignment::D_array_type T = algn.D;
algn.D = data[t].D;
algn.blocksize = data[t].blocksize;
data[t].D = T;
data[t].blocksize = 0;
if ( index[t].second-- )
{
#if !defined(NDEBUG)
bool const alok =
#endif
libmaus::bambam::BamDecoder::readAlignmentGz(*(streams[t]),data[t],0,false);
#if !defined(NDEBUG)
assert ( alok );
#endif
Q.push(t);
}
return true;
}
Node::Ptr pop() {
if (queue.empty())
return Node::Ptr();
Node::Ptr result = queue.top();
queue.pop();
return result;
}
int expand()
{
Nodes node= nodes.top();
getch();
if(nodes.size()==0)
{
cout<<"error";
getch();
return 0;
}
nodes.pop();
if(visited[node.node]==1)
return 0;
else
visited[node.node]=1;
if(node.node==end)
{
cout<<"finalcost"<<node.cost;
return 1;
}
else
{
for(int j=0;j<n;j++)
{
if(a[j][node.node]!=0)
{
nodes.push(Nodes(j,node.cost+a[j][node.node]));
}
}
}
return 0;
}
int main() {
freopen("F.in", "r", stdin);
while (scanf("%d%d", &n, &m) == 2 && n && m) {
for (int i = 1; i <= n; i++) {
scanf("%s", map[i] + 1);
}
scanf("%d%d", &sx, &sy);
scanf("%d%d", &ex, &ey);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
v[i][j] = false;
d[i][j] = INF;
}
heap.push(std::make_pair(d[sx][sy] = 0, std::make_pair(sx, sy)));
while (!heap.empty()) {
std::pair<int, std::pair<int, int> > top = heap.top(); heap.pop();
if (v[top.second.first][top.second.second]) continue;
v[top.second.first][top.second.second] = true;
for (int dir = 0; dir < 4; dir++) {
int nx = top.second.first + dx[dir];
int ny = top.second.second + dy[dir];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
int cost = map[nx][ny] == '.';
if (!v[nx][ny] && d[nx][ny] > d[top.second.first][top.second.second] + cost) {
d[nx][ny] = d[top.second.first][top.second.second] + cost;
heap.push(std::make_pair(d[nx][ny], std::make_pair(nx, ny)));
}
}
}
printf("%d\n", d[ex][ey]);
}
return 0;
}
void operator<<(std::priority_queue<_Tp,Range,Compare> lhs)
{
for(;!lhs.empty();){
std::cout<<lhs.top()<<token;
lhs.pop();
}
std::cout<<last_token<<std::flush;
}
inline P top_priority(void) const
{
delay_mtx.lock();
P ret(data.top().priority);
delay_mtx.unlock();
return ret;
}
double Median::getMedian(void)
{
size_t l = maxHeap1.size();
size_t m = minHeap2.size();
if (l == 0 && m == 0) {
throw std::invalid_argument("No elements inserted yet");
}
if (l - m == 0) {
return (maxHeap1.top() + minHeap2.top()) / 2.0;
} else {
if (l > m) {
return maxHeap1.top();
} else {
return minHeap2.top();
}
}
}
//Maintains the size of the priority queue at the specified size with each push
//For now this function is for priority queue that is in ascending order, top is smallest.
void pushPriorityQueueBounded(std::priority_queue<int, std::vector<int>, std::greater<int> > &pq,
int newElement, unsigned long priorityQueueBound)
{
if(pq.empty() || newElement > pq.top())
pq.push(newElement);
if(pq.size() > priorityQueueBound)
pq.pop();
}
inline T pop(void)
{
delay_mtx.lock();
T ret(data.top().item);
data.pop();
delay_mtx.unlock();
return ret;
}
// Update the Queue. If the queue size less than K, just push.
// Otherwise, if the new value less than the max value, delete the max
// and push new node into queue.
void updataQ(std::priority_queue<Node>& q, RealT d, int i){
if(q.size() < K) q.push(Node(i,d));
else{
if(q.top().dis > d){
q.pop();
q.push(Node(i,d));
}
}
}
int Merge(const int num) {
int ret = 0;
for (int i=0; i<num; i++) {
ret += sands.top();
sands.pop();
}
ans += ret;
return ret;
}
void AddToHeaps(std::priority_queue<double, std::vector<double>, std::greater<double> >& m,
std::priority_queue<double>& M, double x){
// decide on initial heap to place element into
if(m.empty() || x < m.top())
M.push(x);
else
m.push(x);
// make sure that heaps are balanced
if(m.size() > M.size() + 1){
M.push( m.top() );
m.pop();
}
else if(M.size() > m.size() + 1){
m.push( M.top() );
M.pop();
}
}
double NextTime()
{
//std::lock_guard<std::mutex> lock(MUTEX);
if( QUEUE.empty() ) {
return 0;
} else {
return QUEUE.top();
}
}
void simulation::run () {
while (! eventQueue.empty ()) {
event * nextEvent = eventQueue.top ();
eventQueue.pop ();
time = nextEvent->time;
nextEvent->processEvent ();
delete nextEvent;
}
}
bool pop_front(T& data)
{
std::lock_guard<std::mutex> guard(mtx);
if (pq.size() > 1)
{
data = pq.top();
pq.pop();
return true;
}
return false;
};
// Output the Queue
void display(std::priority_queue<Node>& q){ // reverse
std::vector<Node> v;
v.reserve(K);
while (!q.empty()){
v.push_back(q.top());
q.pop();
}
for(int i=K;i>0;i--){
PrintfNode(v[i-1]);
}
}
void rearrange(Attributes *attr, TWeight score)
{
AttrsPtr a;
while ((a = opened.top()), opened.pop(), (a.pa != attr)) temp_buff.push_back(a);
a.pa->fscore = score;
opened.push(a);
while (!temp_buff.empty())
{
opened.push(temp_buff.back());
temp_buff.pop_back();
}
}
