Esempio n. 1
0
int main(){
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)scanf("%lld",&w[i]);
	while((n-1)%(k-1)!=0)n++;
	for(int i=1;i<=n;i++)q.push(make_pair(w[i],0));
	LL ans1=0,ans2=0;
	while(q.size()>1){
		LL res=0,dep=0;
		for(int i=0;i<k;i++){
			res+=q.top().first;
			dep=max(q.top().second,dep);
			q.pop();
		}
		ans1+=res;
		ans2=max(ans2,dep+1);
		q.push(make_pair(res,dep+1));
	}
	cout<<ans1<<endl;
	cout<<ans2<<endl;
	return 0;
}
Esempio n. 2
0
int main()
{
    //freopen ("1msched.txt","r",stdin);
    freopen ("msched.in","r",stdin);
    freopen ("msched.out","w",stdout);

    int n, i, j, k;
    PII p;

    cin >> n;
    for (i = 0; i < n; i++)
    {
        cin >> j >> k;
        v.pb (make_pair(k,-j));
    }

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

    for (i = 0; i < n; i++)
    {
        p = v[i];
        k = p.x;
        q.push(p.y);
        while(!q.empty()&&q.size() > k)
            q.pop();
    }

    int ans = 0;
    while(!q.empty()) {
        ans -= q.top();
        q.pop();
    }

    cout << ans << endl;


    return 0;
}
Esempio n. 3
0
int main(){
	int n ;
	cin >> n;
	int A[n],B[n];
	for(int i = 0 ; i< n;i++)
		cin >> A[i];
	for(int i = 0 ; i< n;i++)
		cin >> B[i];
	sort(A,A+n);
	sort(B,B+n);
	for(int i = 0 ; i < n;i++)
		heap.push(A[i]+B[0]);
	
	for(int i = 1;i<n;i++){
		for(int j = 0 ; j< i;j++)
		{
			int sum = B[i]+A[j];
			if(heap.size()<n)heap.push(sum);
			else{
				if(sum< heap.top()){
					heap.pop();
					heap.push(sum);
				}
		
			}
	
		}
	}
		
	deque<int> c;
	while(!heap.empty()){
		c.push_front(heap.top());
		heap.pop();
	}
	for(int i = 0 ; i < c.size();i++)
		cout<<c[i]<<" ";
	cout<<endl;
}
 void build(char* Table) {
     for (int i = 0; i < 26; ++ i) {
         if (Table[i] > 0) {
             Node* node = new Node();
             node->freq = Table[i];
             node->val =(char) (i + 'A');
             myQueue.push(node);
         }
     }
     while (myQueue.size() > 1) {
         Node* first = myQueue.top();
         myQueue.pop();
         Node* second = myQueue.top();
         myQueue.pop();
         Node* tmp = new Node();
         tmp->val = '*';
         tmp->freq = first->freq + second->freq;
         tmp->left = first;
         tmp->right = second;
         myQueue.push(tmp);
     }
     root=myQueue.top();
 }
Esempio n. 5
0
int main(){
	scanf("%d",&N);
	for(int i=0; i<N; i++){
		scanf("%d",&a);
		pq.push( -a );
	}
	int cnt = 0;
	while( !pq.empty() ){
		if( pq.size() == 1 ){
			pq.pop(); cnt ++;
			break;
		}
		int a = pq.top(); pq.pop();
		if( pq.top() == a ){
			pq.pop();
			pq.push( a-1 );
		}else{
			cnt ++;
		}
	}
	printf("%d",cnt);
	return 0;
}
Esempio n. 6
0
int main(){
  while(scanf("%d",&n)&&n){
    ans=0;
    while(!Q.empty())
      Q.pop();
    int tmp;
    for(int i=0;i<n;i++){
      scanf("%d",&tmp);
      Q.push(tmp);
    }
    while(Q.size()!=1){
      int a=Q.top();
      Q.pop();
      int b=Q.top();
      Q.pop();
      a+=b;
      ans+=a;
      Q.push(a);
    }
    printf("%d\n",ans);
  }
  return 0;
}
Esempio n. 7
0
		void process()
		{
			PostedEvent *event;
			EventData *data;
			unsigned short processed = 0;
			
			while (posted_events.size() > 0 && processed < process_max)
			{
				event = posted_events.top();
				data = &signals[event->name];
				
				data->signal(event->args);
			
				if (data->deallocator)
				{
					data->deallocator(event->args);
				}
				
				delete event;
				posted_events.pop();
				processed++;
			}
		}
    //Function builds huffman tree and returns the root node
    shared_ptr<HuffmanNode> HuffmanTree::buildTree(priority_queue<shared_ptr<HuffmanNode>,vector<shared_ptr<HuffmanNode>>,HuffmanComparator> &priorityQueue)
    {
        shared_ptr<HuffmanNode> newParentNode = nullptr;
        //Loops until all nodes linked together and all thats left is the root node
        while (priorityQueue.size() > 1){

            //Get the smallest frequency letter as a Huffman Node - this will be the left node of the new parent
            shared_ptr<HuffmanNode> leftOfNewParent = priorityQueue.top();
            priorityQueue.pop();
            //Get the second smallest frequency letter - right side of parent
            shared_ptr<HuffmanNode> rightOfNewParent = priorityQueue.top();
            priorityQueue.pop();
            //Frequency of parent is the summation of the frequency of its children
            int parentFrequency = (*leftOfNewParent).getFrequency() + (*rightOfNewParent).getFrequency();

            newParentNode.reset(new HuffmanNode('\0',parentFrequency)); //Empty char and summed frequency
            newParentNode->left = leftOfNewParent; //Set pointers from parent to the children nodes so they don't get lost(out of scope)
            newParentNode->right = rightOfNewParent;
            priorityQueue.push(newParentNode); //Push new parent node onto priority queue to be possibly merged again
        }

        return newParentNode; //return the last edited node - root node
    }
void BuildTree() //Building Huffman Tree
{

    for (int i = 0; i < m; ++ i)

        {
            Node * node = new Node(); //creating a new node of rxn propensity value
            node->prop = Table[i];
            node->left=nullptr;
            node->right=nullptr;
            node->rxno=i+1;


            myQueue.push(node);  //pushing the contents into priority queue which is min -heap
        }
    cout << "qUEQUE Top  "<<myQueue.top()->prop<<endl;


    while (myQueue.size() > 1)  //Building Huffman Tree
    {
        Node * f = myQueue.top();
        myQueue.pop();
        Node * s = myQueue.top();
        myQueue.pop();
        Node * tmp = new Node();
        tmp->prop = f->prop+ s->prop;
        cout<<tmp->prop<<endl;
        tmp->left = f;
        tmp->right = s;

       cout<<"Hello 2"<<endl;

        myQueue.push(tmp);
    }

cout << "qUEQUE Top"<<myQueue.top()->prop<<endl;
}
Esempio n. 10
0
int main()
{
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);

	long long a,b;

	while(~scanf("%d",&N))
	{
		while(!que.empty())
			que.pop();

		ans=0;

		while(N--)
		{
			scanf("%lld",&a);
			que.push(a);
		}

		while(que.size()>1)
		{
			a=que.top();
			que.pop();
			b=que.top();
			que.pop();

			ans+=a+b;
			que.push(a+b);
		}

		printf("%lld\n",ans);
	}
	
	return 0;
}
Esempio n. 11
0
int main()
{
	int a,n,s,t1,t2;
	while(cin>>n)
	{
		if(n==0)break;
		for(int i = 0; i < n; i++)
		{
			cin>>a;
			q.push(a);
		}
		s = 0;
		while(q.size()>1)
		{
			t1 = q.top(); q.pop();
			t2 = q.top(); q.pop();
			s+=t1+t2;
			q.push(t1+t2);
		}
		cout<<s<<endl;
		q.pop();
	}
	return 0;
}
Esempio n. 12
0
int main()
{
	freopen("huffman.in", "r", stdin);
	freopen("huffman.out", "w", stdout);
	ios::sync_with_stdio(false);
	int n; cin >> n;
	for(int i = 0; i < n; i++)
	{
		int x; cin >> x;
		pq.push(-x);
	}
	lli ans = 0;
	while(pq.size() != 1)
	{
		lli t0 = pq.top();
		pq.pop();
		lli t1 = pq.top();
		pq.pop();
		ans -= t0+t1;
		pq.push(t0+t1);
	}
	cout << ans << '\n';
	return 0;
}
Esempio n. 13
0
int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */
    scanf("%d",&n);
    int cnt = 0;
    while(n -- ){
        double ans = 0;
        int lval, rval;
        int inpt;
        scanf("%d",&inpt);
        ++ cnt;
        if(cnt == 1){
            ans = inpt;
            lg_q.push(inpt);
        }else{
            if(inpt <= lg_q.top()){
                lg_q.push(inpt);
                if(lg_q.size() > sm_q.size() + 1){
                    inpt = lg_q.top();
                    lg_q.pop();
                    sm_q.push(inpt);
                }
            }else{
                sm_q.push(inpt);
                if(lg_q.size() < sm_q.size()){
                    inpt = sm_q.top();
                    sm_q.pop();
                    lg_q.push(inpt);
                }
            }
            if(lg_q.size() == sm_q.size()){
                lval = lg_q.top();
                rval = sm_q.top();
                ans = ((double)lval + (double)rval)/2.0;
            }else{
                ans = lg_q.top();
            }
        }
        printf("%.1lf\n",ans);
    }
    return 0;
}
int main () {
    while(scanf("%d", &N) != EOF){
           if(MinQ.size() == 0){
                          MinQ.push(N);
                          printf("%d\n",N);
                          }
           else if(MaxQ.size() == 0){
                MaxQ.push(N);
                printf("%d\n",(MaxQ.top() + MinQ.top()) / 2);
                if(MaxQ.top() < MinQ.top()) Swap();
                }
           else if(MinQ.size() == MaxQ.size()){
                if(N <= MinQ.top()){
                     MinQ.push(N);
                     printf("%d\n",MinQ.top());
                     }
                else{
                     MaxQ.push(N);
                     int a = MaxQ.top();
                     MaxQ.pop();
                     MinQ.push(a);
                     printf("%d\n",MinQ.top());
                     }
                }
           else if(MinQ.size() - MaxQ.size() == 1){
                if(N <= MinQ.top()){
                     MinQ.push(N);
                     int a = MinQ.top();
                     MinQ.pop();
                     MaxQ.push(a);
                     printf("%d\n",(MaxQ.top() + MinQ.top()) / 2);
                     }
                else{
                     MaxQ.push(N);
                     printf("%d\n",(MaxQ.top() + MinQ.top()) / 2);
                     }
                }
           }
    return 0;
    }
Esempio n. 15
0
bool improve_solution_1(
    graph<pair<int, int>>* solution,
    graph<int>& g1,
    graph<int>& g2,
    unordered_map<int, int>& g2_to_g1_mapping,
    unordered_set<int>& mapped_nodes,
    unordered_set<int>& unmapped_nodes,
    vector<int>& unmapped_nodes_vector,
    float neighbourhood_proportion,
    bool strict_comparisons,
    unsigned int tabu_list_size,
    priority_queue<movement, vector<movement>,
        movement_compare>& tabu_queue,
    movement_compare& mc,
    vector<movement>& tabu_list,
    bool allow_worse,
    const float time_delta,
    int& max_edge_diff,
    const float aspiration_threshold
) {
    vector<pair<int, int>> solution_vertices =
        solution->get_vertices();

    bool use_tabu = tabu_list_size > 0;
    bool is_tabu_mapping = false;
    vector<pair<int, int>> tabu_free_mappings;

    bool any_improvement = false;
    pair<int, int> best_to_remove;
    pair<int, int> best_to_add;
    int best_edge_diff = 0;
    vector<int> best_new_edges;

    // This iterates over every pair present in the solution, each of
    // which corresponds to a vertex in g1
    for (unsigned int i = 0; i < solution->n(); i++) {
        // This iterates over the possible nodes in g2 to which the
        // current g1 vertex could be associated

        unsigned int neighbourhood_size = unmapped_nodes_vector.size();

        for (unsigned int j = 0; j < neighbourhood_size; j++) {
            if (rand() < neighbourhood_proportion * RAND_MAX) {
                // Possible new pair. Let's evaluate its potential
                int node_mapped    = solution_vertices[i].first;   // part of g1
                int node_to_remove = solution_vertices[i].second;  // part of g2
                int node_to_add    = unmapped_nodes_vector[j];     // part of g2

                int lost_edges = solution->degree({node_mapped, node_to_remove});
                vector<int> new_edges;

                vector<int> node_to_add_neigh = g2.neighbours(node_to_add);
                for (unsigned int k = 0; k < node_to_add_neigh.size(); k++) {
                    if (node_to_add_neigh[k] != node_to_remove &&
                        unmapped_nodes.find(node_to_add_neigh[k]) ==
                            unmapped_nodes.end() &&
                        g1.adjacent(node_mapped,
                            g2_to_g1_mapping[node_to_add_neigh[k]])
                    )
                    {
                        new_edges.push_back(node_to_add_neigh[k]);
                    }
                }

                int edge_diff = new_edges.size() - lost_edges;

                // Check if this movement is tabu
                if (use_tabu && allow_worse) {
                    for (unsigned int k = 0; k < tabu_list.size(); k++) {
                        // If this movement is in the tabu list
                        if (tabu_list[k].mapping.first == node_mapped &&
                                tabu_list[k].mapping.second == node_to_add
                            ) {
                            // If it doesn't gain much edges, we discard it
                            if (edge_diff < max_edge_diff*aspiration_threshold) {
                                is_tabu_mapping = true;
                                break;
                            }
                        }
                    }

                    // Try with next potential matching
                    if (is_tabu_mapping) {
                        is_tabu_mapping = false;
                        continue;
                    }
                    else {
                        tabu_free_mappings.push_back({i, j});
                    }
                }

                bool is_improvement = strict_comparisons
                                        ? edge_diff > best_edge_diff
                                        : edge_diff >= best_edge_diff;

                if (is_improvement) {
                    any_improvement = true;
                    best_to_add = {node_mapped, node_to_add};
                    best_to_remove = {node_mapped, node_to_remove};
                    best_edge_diff = edge_diff;
                    best_new_edges = new_edges;
                }
            }
        }
    }

    if (use_tabu && allow_worse && !tabu_free_mappings.empty() && !any_improvement) {
        any_improvement = true;
        pair<int, int> random_valid_mapping = tabu_free_mappings[rand() % tabu_free_mappings.size()];

        int node_mapped    = solution_vertices[random_valid_mapping.first].first;   // part of g1
        int node_to_remove = solution_vertices[random_valid_mapping.first].second;  // part of g2
        int node_to_add    = unmapped_nodes_vector[random_valid_mapping.second];    // part of g2

        int lost_edges = solution->degree({node_mapped, node_to_remove});

        vector<int> new_edges;

        vector<int> node_to_add_neigh = g2.neighbours(node_to_add);
        for (unsigned int k = 0; k < node_to_add_neigh.size(); k++) {
            if (node_to_add_neigh[k] != node_to_remove &&
                unmapped_nodes.find(node_to_add_neigh[k]) ==
                    unmapped_nodes.end() &&
                g1.adjacent(node_mapped,
                    g2_to_g1_mapping[node_to_add_neigh[k]])
            )
            {
                new_edges.push_back(node_to_add_neigh[k]);
            }
        }

        int edge_diff = new_edges.size() - lost_edges;

        best_to_add = {node_mapped, node_to_add};
        best_to_remove = {node_mapped, node_to_remove};
        best_edge_diff = edge_diff;
        best_new_edges = new_edges;
    }

    if (any_improvement) {
        solution->remove_node(best_to_remove);
        g2_to_g1_mapping.erase(best_to_remove.second);
        unmapped_nodes_vector.push_back(best_to_remove.second);
        unmapped_nodes.insert(best_to_remove.second);

        solution->add_node(best_to_add);
        g2_to_g1_mapping.insert({best_to_add.second, best_to_add.first});
        unmapped_nodes_vector.erase(find(unmapped_nodes_vector.begin(),
            unmapped_nodes_vector.end(), best_to_add.second));
        unmapped_nodes.erase(best_to_add.second);

        for (unsigned int i = 0; i < best_new_edges.size(); i++) {
            pair<int, int> new_edge_dest = {
                g2_to_g1_mapping[best_new_edges[i]],
                best_new_edges[i]
            };
            solution->add_edge(best_to_add, new_edge_dest);
        }

        if (use_tabu) {
            // If this is the new best edge diff, we update our max
            if (best_edge_diff > max_edge_diff) {
                max_edge_diff = best_edge_diff;
            }

            // Update time for each movement
            for (unsigned int i = 0; i < tabu_list.size(); i++) {
                tabu_list[i].time += time_delta;
            }

            // Update heap
            if (!tabu_queue.empty()) {
                make_heap(const_cast<movement*>(&tabu_queue.top()),
                    const_cast<movement*>(&tabu_queue.top()) + tabu_queue.size(),
                    mc);
            }

            movement mov(best_to_remove, best_edge_diff, 0);

            if (tabu_list.size() < tabu_list_size) {
                mov.pos = tabu_list.size();
                tabu_list.push_back(mov);
            }
            else {
                mov.pos = tabu_queue.top().pos;
                tabu_queue.pop();
                tabu_list[mov.pos] = mov;
            }

            // Add movement to tabu heap
            tabu_queue.push(mov);
        }

        return true;
    } else {
        return false;
    }
}
 // Returns the median of current data stream
 double findMedian() {
     return max_heap.size() > min_heap.size()
         ?max_heap.top():((max_heap.top()-min_heap.top())/2.0);
     
 }
Esempio n. 17
0
 // Adds a number into the data structure.
 void addNum(int num) {
     if (minHeap.size() > 0 && minHeap.top() < num) minHeap.push(num);
     else maxHeap.push(num);
 }
Esempio n. 18
0
    int size() const{
	return data.size();
    }
 // Returns the median of current data stream
 double findMedian() {
     return small.size() > large.size()
         ? small.top()
         : (small.top() - large.top()) / 2.0;
 }
Esempio n. 20
0
bool improve_solution_2(
    graph<pair<int, int>>* solution,
    graph<int>& g1,
    graph<int>& g2,
    unordered_map<int, int>& g2_to_g1_mapping,
    unordered_set<int>& mapped_nodes,
    unordered_set<int>& unmapped_nodes,
    vector<int>& unmapped_nodes_vector,
    float neighbourhood_proportion,
    bool strict_comparisons,
    unsigned int tabu_list_size,
    priority_queue<movement, vector<movement>,
        movement_compare>& tabu_queue,
    movement_compare& mc,
    vector<movement>& tabu_list,
    bool allow_worse,
    const float time_delta,
    int& max_edge_diff,
    const float aspiration_threshold
) {
    enum action_type {none, swap, exchange};

    vector<pair<int, int>> solution_vertices = solution->get_vertices();
    vector<int> g2_vertices = g2.get_vertices();

    bool use_tabu = tabu_list_size > 0;
    bool is_tabu_mapping = false;
    vector<pair<int, int>> tabu_free_mappings;
    vector<bool> tabu_free_mapping_type;

    bool any_improvement = false;
    int best_edge_diff = 0;
    action_type best_action = none;
    pair<int, int> best_node_1;
    pair<int, int> best_node_2;
    vector<int> best_new_edges_1;
    vector<int> best_new_edges_2;

    for (unsigned int i = 0; i < g2.n(); i++) {
        bool i_mapped = mapped_nodes.find(g2_vertices[i]) != mapped_nodes.end();
        for (unsigned int j = 0; j < i; j++) {
            if (rand() < neighbourhood_proportion * RAND_MAX) {
                bool j_mapped = mapped_nodes.find(g2_vertices[j]) != mapped_nodes.end();

                action_type action;
                int node_1;  // to add if exchange
                int node_2;  // to remove if exchange
                int node_1_mapped;
                int node_2_mapped;
                int lost_edges;
                vector<int> new_edges_1;
                vector<int> new_edges_2;
                int edge_diff = -1;  // to avoid trying to make invalid moves

                if (i_mapped && j_mapped) {
                    // cout << "  try SWAP  " << g2_vertices[i] << " <-> " << g2_vertices[j] << endl;
                    action = swap;

                    node_1 = g2_vertices[i];
                    node_2 = g2_vertices[j];
                    node_1_mapped = g2_to_g1_mapping[node_1];
                    node_2_mapped = g2_to_g1_mapping[node_2];

                    lost_edges =
                        solution->degree({node_1_mapped, node_1}) +
                        solution->degree({node_2_mapped, node_2});
                    if (solution->adjacent({node_1_mapped, node_1}, {node_2_mapped, node_2})) {
                        lost_edges -= 2;
                    }

                    vector<int> node_1_neigh = g2.neighbours(node_1);
                    for (unsigned int k = 0; k < node_1_neigh.size(); k++) {
                        if (node_1_neigh[k] != node_2 &&
                            unmapped_nodes.find(node_1_neigh[k]) ==
                                unmapped_nodes.end() &&
                            g1.adjacent(node_2_mapped,
                                g2_to_g1_mapping[node_1_neigh[k]])
                        )
                        {
                            new_edges_1.push_back(node_1_neigh[k]);
                        }
                    }

                    vector<int> node_2_neigh = g2.neighbours(node_2);
                    for (unsigned int k = 0; k < node_2_neigh.size(); k++) {
                        if (node_2_neigh[k] != node_1 &&
                            unmapped_nodes.find(node_2_neigh[k]) ==
                                unmapped_nodes.end() &&
                            g1.adjacent(node_1_mapped,
                                g2_to_g1_mapping[node_2_neigh[k]])
                        )
                        {
                            new_edges_2.push_back(node_2_neigh[k]);
                        }
                    }
                    // cout << "      lost edges:  " << lost_edges  << endl;
                    // cout << "      new edges 1: " << new_edges_1 << endl;
                    // cout << "      new edges 2: " << new_edges_2 << endl;

                    edge_diff = new_edges_1.size() + new_edges_2.size() - lost_edges;
                    // cout << "    edge diff: " << edge_diff << endl;
                }
                else if (i_mapped || j_mapped) {
                    unsigned int mapped_node = i_mapped ? i : j;
                    unsigned int unmapped_node = i_mapped ? j : i;
                    // cout << "  try EXCHG " << g2_vertices[mapped_node] << " --> " << g2_vertices[unmapped_node] << endl;
                    action = exchange;

                    node_1        = g2_vertices[unmapped_node]; // to add, part of g2
                    node_2        = g2_vertices[mapped_node];   // to remove, part of g2
                    node_2_mapped = g2_to_g1_mapping[node_2];   // part of g1
                    node_1_mapped = node_2_mapped;

                    lost_edges = solution->degree({node_2_mapped, node_2});

                    vector<int> node_1_neigh = g2.neighbours(node_1);
                    for (unsigned int k = 0; k < node_1_neigh.size(); k++) {
                        if (node_1_neigh[k] != node_2 &&
                            unmapped_nodes.find(node_1_neigh[k]) ==
                                unmapped_nodes.end() &&
                            g1.adjacent(node_1_mapped,
                                g2_to_g1_mapping[node_1_neigh[k]])
                        )
                        {
                            new_edges_1.push_back(node_1_neigh[k]);
                        }
                    }

                    // cout << "      lost edges: " << lost_edges  << endl;
                    // cout << "      new edges:  " << new_edges_1 << endl;

                    edge_diff = new_edges_1.size() - lost_edges;
                    // cout << "    edge diff: " << edge_diff << endl;
                }

                // Check if this movement is tabu
                if (use_tabu && allow_worse) {
                    for (unsigned int k = 0; k < tabu_list.size(); k++) {
                        // If this movement is in the tabu list
                        if (tabu_list[k].mapping.first == node_1 &&
                            tabu_list[k].mapping.second == node_2
                        ) {
                            // If it doesn't gain much edges, we discard it
                            if (((tabu_list[k].is_swap && action == swap) ||
                                (!tabu_list[k].is_swap && action == exchange)) &&
                                edge_diff < max_edge_diff*aspiration_threshold
                            ) {
                                is_tabu_mapping = true;
                                break;
                            }
                        }
                    }

                    // Try with next potential matching
                    if (is_tabu_mapping) {
                        is_tabu_mapping = false;
                        continue;
                    }
                    else {
                        tabu_free_mappings.push_back({node_1, node_2});
                        tabu_free_mapping_type.push_back(action == swap);
                    }
                }

                bool is_improvement = strict_comparisons
                                        ? edge_diff > best_edge_diff
                                        : edge_diff >= best_edge_diff;

                if (is_improvement) {
                    any_improvement = true;
                    best_edge_diff = edge_diff;
                    best_action = action;
                    best_node_1 = {node_1_mapped, node_1};
                    best_node_2 = {node_2_mapped, node_2};
                    best_new_edges_1 = new_edges_1;
                    best_new_edges_2 = new_edges_2;
                }
            }
        }
    }

    if (use_tabu && allow_worse && !tabu_free_mappings.empty() && !any_improvement) {
        int random_number = rand() % tabu_free_mappings.size();
        int node_1 = tabu_free_mappings[random_number].first;
        int node_2 = tabu_free_mappings[random_number].second;

        action_type action = tabu_free_mapping_type[random_number] ? swap : exchange;
        int node_1_mapped;
        int node_2_mapped;
        int lost_edges;
        vector<int> new_edges_1;
        vector<int> new_edges_2;
        int edge_diff;

        if (action == swap) {
            node_1_mapped = g2_to_g1_mapping[node_1];
            node_2_mapped = g2_to_g1_mapping[node_2];

            lost_edges =
                solution->degree({node_1_mapped, node_1}) +
                solution->degree({node_2_mapped, node_2});
            if (solution->adjacent({node_1_mapped, node_1}, {node_2_mapped, node_2})) {
                lost_edges -= 2;
            }

            vector<int> node_1_neigh = g2.neighbours(node_1);
            for (unsigned int k = 0; k < node_1_neigh.size(); k++) {
                if (node_1_neigh[k] != node_2 &&
                    unmapped_nodes.find(node_1_neigh[k]) ==
                        unmapped_nodes.end() &&
                    g1.adjacent(node_2_mapped,
                        g2_to_g1_mapping[node_1_neigh[k]])
                )
                {
                    new_edges_1.push_back(node_1_neigh[k]);
                }
            }

            vector<int> node_2_neigh = g2.neighbours(node_2);
            for (unsigned int k = 0; k < node_2_neigh.size(); k++) {
                if (node_2_neigh[k] != node_1 &&
                    unmapped_nodes.find(node_2_neigh[k]) ==
                        unmapped_nodes.end() &&
                    g1.adjacent(node_1_mapped,
                        g2_to_g1_mapping[node_2_neigh[k]])
                )
                {
                    new_edges_2.push_back(node_2_neigh[k]);
                }
            }

            edge_diff = new_edges_1.size() + new_edges_2.size() - lost_edges;
        }
        else {
            node_2_mapped = g2_to_g1_mapping[node_2];
            node_1_mapped = node_2_mapped;

            lost_edges = solution->degree({node_2_mapped, node_2});

            vector<int> node_1_neigh = g2.neighbours(node_1);
            for (unsigned int k = 0; k < node_1_neigh.size(); k++) {
                if (node_1_neigh[k] != node_2 &&
                    unmapped_nodes.find(node_1_neigh[k]) ==
                        unmapped_nodes.end() &&
                    g1.adjacent(node_1_mapped,
                        g2_to_g1_mapping[node_1_neigh[k]])
                )
                {
                    new_edges_1.push_back(node_1_neigh[k]);
                }
            }

            edge_diff = new_edges_1.size() - lost_edges;
        }

        any_improvement = true;
        best_edge_diff = edge_diff;
        best_action = action;
        best_node_1 = {node_1_mapped, node_1};
        best_node_2 = {node_2_mapped, node_2};
        best_new_edges_1 = new_edges_1;
        best_new_edges_2 = new_edges_2;
    }

    if (any_improvement) {
        if (best_action == swap) {
            // cout << "best action SWAP  " << best_node_1 << " <-> " << best_node_2 << " (" << best_edge_diff << ")" << endl;

            bool swapping_adjacents = solution->adjacent(best_node_1, best_node_2);
            solution->remove_node(best_node_1);
            solution->remove_node(best_node_2);

            pair<int, int> new_node_1 = {best_node_2.first, best_node_1.second};
            pair<int, int> new_node_2 = {best_node_1.first, best_node_2.second};

            solution->add_node(new_node_1);
            solution->add_node(new_node_2);

            if (swapping_adjacents) {
                solution->add_edge(new_node_1, new_node_2);
            }

            for (unsigned int i = 0; i < best_new_edges_1.size(); i++) {
                pair<int, int> new_edge_dest = {
                    g2_to_g1_mapping[best_new_edges_1[i]],
                    best_new_edges_1[i]
                };
                solution->add_edge(new_node_1, new_edge_dest);
            }

            for (unsigned int i = 0; i < best_new_edges_2.size(); i++) {
                pair<int, int> new_edge_dest = {
                    g2_to_g1_mapping[best_new_edges_2[i]],
                    best_new_edges_2[i]
                };
                solution->add_edge(new_node_2, new_edge_dest);
            }

            g2_to_g1_mapping[new_node_1.second] = new_node_1.first;
            g2_to_g1_mapping[new_node_2.second] = new_node_2.first;
        }

        else if (best_action == exchange) {
            // cout << "best action EXCHG " << best_node_2 << " --> " << best_node_1 << " (" << best_edge_diff << ")" << endl;
            solution->remove_node(best_node_2);
            g2_to_g1_mapping.erase(best_node_2.second);
            mapped_nodes.erase(best_node_2.second);
            unmapped_nodes.insert(best_node_2.second);
            unmapped_nodes_vector.push_back(best_node_2.second);

            solution->add_node(best_node_1);
            g2_to_g1_mapping.insert({best_node_1.second, best_node_1.first});
            mapped_nodes.insert(best_node_1.second);
            unmapped_nodes.erase(best_node_1.second);
            unmapped_nodes_vector.erase(find(unmapped_nodes_vector.begin(),
                unmapped_nodes_vector.end(), best_node_1.second));

            for (unsigned int i = 0; i < best_new_edges_1.size(); i++) {
                pair<int, int> new_edge_dest = {
                    g2_to_g1_mapping[best_new_edges_1[i]],
                    best_new_edges_1[i]
                };
                solution->add_edge(best_node_1, new_edge_dest);
            }
        }

        if (use_tabu) {
            // If this is the new best edge diff, we update our max
            if (best_edge_diff > max_edge_diff) {
                max_edge_diff = best_edge_diff;
            }

            // Update time for each movement
            for (unsigned int i = 0; i < tabu_list.size(); i++) {
                tabu_list[i].time += time_delta;
            }

            // Update heap
            if (!tabu_queue.empty()) {
                make_heap(const_cast<movement*>(&tabu_queue.top()),
                    const_cast<movement*>(&tabu_queue.top()) + tabu_queue.size(),
                    mc);
            }

            movement mov({best_node_2.second, best_node_1.second},
                best_edge_diff, 0, best_action == swap);

            if (tabu_list.size() < tabu_list_size) {
                mov.pos = tabu_list.size();
                tabu_list.push_back(mov);
            }
            else {
                mov.pos = tabu_queue.top().pos;
                tabu_queue.pop();
                tabu_list[mov.pos] = mov;
            }

            // Add movement to tabu heap
            tabu_queue.push(mov);
        }
        return true;
    } else {
        // cout << "no improvements are possible" << endl;
        return false;
    }
}
Esempio n. 21
0
File: code.cpp Progetto: sjj118/Code
	int size(){return A.size()-B.size();}
Esempio n. 22
0
int Findpath::ComputeSaddle(short *str1, short *str2)
{
  // compute the distance and all the moves.
  vector<move_fp> moves = GetMoves(str1, str2);

  int dist = (int)moves.size();

  intermediate_pk inter_tmp(str1, energy_of_struct_pk(seq, str1, s0, s1, verbose_lvl), moves);
  pqueue.push(inter_tmp);
  structs_visited[allocopy(inter_tmp.structure)] = inter_tmp.energy;

  // for each distance do
  for (int i=0; i<dist; i++) {

    if (verbose_lvl > 1) fprintf(stderr, "STR: distance %4d\n", i);


    // for each in maxkeep do:
    int cnt = 0;
    while (cnt < maxkeep) {

      int size = pqueue.size();

      //if (size == 0 && i == dist-1) break;

      if (size == 0) fprintf(stderr, "%s\n%s\n", pt_to_str_pk(str1).c_str(), pt_to_str_pk(str2).c_str());

      intermediate_pk inter = pqueue.top();
      //if (verbose_lvl > 1) fprintf(stderr, "ATT: %s %6.2f %6.2f %d\n", pt_to_str_pk(inter.structure).c_str(), inter.Sen/100.0, inter.energy/100.0, inter.dist);
      //if (verbose_lvl > 1) fprintf(stderr, "CHc: %s %6.2f\n", pt_to_str_pk(inter.pknot.str).c_str(), inter.pknot.energy/100.0);


      if (inter.dist ==i) pqueue.pop();
      else break;

      // if we are going to proceed the structure with lower energy than optimal:
      int stored_en = structs_visited[inter.structure];
      if (stored_en != inter.energy) {
        free(inter.structure);
        continue;
      }

      if (verbose_lvl > 1) fprintf(stderr, "GET: %s %6.2f %6.2f %d%c\n", pt_to_str_pk(inter.structure).c_str(), inter.Sen/100.0, inter.energy/100.0, inter.dist, inter.pknot.pknots.size()>0?'P':'-');
      //if (verbose_lvl > 1) fprintf(stderr, "CHc: %s %6.2f\n", pt_to_str_pk(inter.pknot.str).c_str(), inter.pknot.energy/100.0);


      // apply movement
      for (set<move_fp>::iterator it=inter.moves_todo.begin(); it!=inter.moves_todo.end(); it++) {



        if (verbose_lvl > 1) {
          short *st = allocopy(inter.structure);
          if (MoveStr(st, it->left, it->right)) {
            fprintf(stderr, "TRY: %s %6.2f %6.2f %d\n", pt_to_str_pk(st).c_str(), inter.Sen/100.0, inter.energy/100.0, inter.dist);
          }
          free(st);
        }
        // check if we can move it
        if (it->left<0 || inter.pknot.CanInsert(it->left, it->right)) { // can be faster

          //fprintf(stderr, "%s %d %d\n", pt_to_str_pk(inter.structure).c_str(), it->left, it->right);

          //int energy_chng = energy_of_move_PK(inter.pk, inter.structure, Enc.s0, Enc.s1, it->left, it->right, Enc.verbose_lvl);
          //if (structs_visited.find()) // faster

          // insert new one into the queue ;-)
          Insert(inter, it, verbose_lvl);
          /*intermediate next (inter, it, energy_chng);
          pqueue.push(next);*/

        }
      }
      // if we want to have it like the findpath...
      ///if (!Contains_PK(inter.structure))
      cnt++;

      free(inter.structure);

    }
    //clean:
    while (pqueue.top().dist == i) {
      free(pqueue.top().structure);
      pqueue.pop();
    }
  }

  result = pqueue.top();
  pqueue.pop();

  //clean again:
  while (!pqueue.empty()) {
    free(pqueue.top().structure);
    pqueue.pop();
  }

  for (auto it=structs_visited.begin(); it!=structs_visited.end(); it++) {
    free(it->first);
  }

  return result.Sen;
}
Esempio n. 23
0
int main(){
//freopen("in.txt","r",stdin);
freopen("d.in","r",stdin);
freopen("d.out","w",stdout);
	int n;
	cin>>n;



	int ai;
	map<int,int> mp;
	for(int i = 0; i < n; ++i){
		scanf("%d",&ai);
		if(mp.find(ai) == mp.end())
			mp[ai] = 1;
		else
		{
			int t = mp[ai];
			mp[ai] = t+1;
		}
	}


	

	for(map<int,int>::iterator it = mp.begin();it!=mp.end();++it){
		push(it->second,it->first);
	}
/*
	if(odd.size() == 1 && even.size() == 1){
		pii p = even.top();
		int L = p.first/2;
		cout<<L;
		for(int i = 0; i < L; ++i){
			printf("\n%d %d %d %d",p.second,p.second,odd[0].second,odd[0].second);
		}
		return 0;
	}
*/
	

	while(!ones.empty()||!odd.empty()||!even.empty()){
		if(odd.empty() && even.empty())
			fail();

		if(ones.empty() && odd.empty()){
			vector<pii> b;
			Vpii_from_Q(b,even);
			int mx = b.back().second;
			for(int i = 0; i < b.size() -1 ; ++i){
				for(int j = 0 ; j< b[i].second/2; ++j)
					ans_push(b[i].second,b[i].second,mx,mx);
			}
			break;
		}

		if(odd.size() == 1 && ones.empty() && odd.top().first == max_qnt){
			if(!even.empty()){
				vector<pii> b;
				int max_elem = odd.top().second;
				Vpii_from_Q(b,even);
				int mx = b.back().first;
				for(int i = 0; i < b.size(); ++i){
					for(int j = 0 ; j< b[i].second/2; ++j)
						ans_push(b[i].second,b[i].second,max_elem,max_elem);
				}
			}
			break;
		}

		int a,b,c,d;

		pii min_p = minimum();
		pii min_odd = minimum_odd();
		
		a = b = min_p.second;
		c = min_odd.second;





		push(min_p.first - 2,min_p.second);
		push(min_odd.first + 1,min_odd.second);

		min_odd = minimum_odd();
		d = min_odd.second;
		if(min_odd.first == -1)
		{
			vector<pii> b;
			Vpii_from_Q(b,even);
			if(!b.empty()){
				for(int i = 0;i<b.size()-1;++i)
					push(b[i].first,b[i].second);
				push(b.back().first + 1,b.back().second);
				d = b.back().second;
			}
			
		}

		
	
		push(min_odd.first+1,min_odd.second);

		ans_push(a,b,c,d);
		
	}

	int L = ans[0].size();
	cout<<L;
	for(int i = 0; i <L; ++i)
		printf("\n%d %d %d %d",ans[0][i],ans[1][i],ans[2][i],ans[3][i]);
	return 0;

}
void addNumber(int number) {
  if(low.size()==0 || number<low.top())
    low.push(number);
  else
    high.push(number);
}
void GraphSearch(int n, int k)
{
    int goal_test=0,max_frontier=0;
    vector<State*> successors;

    //frontier and explored elements put in a vector to check successors against.
    vector<State*> frontier;

    //solution path
    vector<State*> path;

    //set initial state of the problem
    State * first, *leaf;
    first=new State(k);
    leaf=new State(k);

    first->initialState(n,k);
    first->depth=0;


    //push the initial state into the frontier
    pq.push(first);

    //keeping track of max queue size
    if(pq.size()>max_frontier)
        max_frontier=pq.size();

    frontier.push_back(first);

    while(true)
    {
        //frontier empty?
        if(pq.empty())
        {
            cout<<"\nNo solution exists\n";
            return;
        }

        //choose a leaf node form the frontier
        leaf=pq.top();
        pq.pop();

         //check to see if we've reached our goal
        goal_test++;

        if(leaf->isGoal(n))
        {   cout<<"\nSuccess!  ";
            cout<<"Depth="<<leaf->depth<<"  No.of iterations = "<<goal_test<<"   Max queue size="<<max_frontier<<endl;

            //display the solution path
            int a,b,path_no;

            path.push_back(leaf);

            while(leaf->getParent()!=NULL)
            {
                leaf=leaf->getParent();

                path.push_back(leaf);

            }

            cout<<"Solution path:\n";

            for(path_no=path.size()-1;path_no>=0;path_no--)
                path[path_no]->display();

            return;

        }

        cout<<"\niteration "<<goal_test<<":   queue="<<max_frontier<<"   h=f+g= "<<leaf->getHeuristic()<<"   depth="<<leaf->depth<<endl;


        //expand the node
        successors=leaf->successor(k);

        //check against every state in the frontier and explored states
        int flag,i;

        vector<State*>::iterator it;

        for(i=0;i<successors.size();i++)
        {
            flag=0;

            for(it=frontier.begin();it!=frontier.end();it++)

                if(successors[i]->isSame((*it),k))
                    flag=1;


            if(flag==0)
            {

                //set parent of the nodes expanded
                successors[i]->setParent(leaf);
                successors[i]->depth=(leaf->depth)+1;
                successors[i]->setHeuristic();
                pq.push(successors[i]);

                //inserting the node in the frontier element list as well- priority queue can't be iterated over
                frontier.push_back(successors[i]);
            }

        }

        //keeping track of max queue size
        if(pq.size()>max_frontier)
            max_frontier=pq.size();

    }



}
 // Returns the median of current data stream
 double findMedian() {
     return small.size() == large.size()
            ? (small.top() + large.top()) / 2.0
            : small.top();
 }
Esempio n. 27
0
int getk() {
	return (minheap.size()) ? -1 * minheap.top() : -1;
}
Esempio n. 28
0
int main(){
	string fileInput = "avioane2";
#ifdef INFOARENA
	freopen((fileInput + ".in").c_str(), "r", stdin);
	freopen((fileInput + ".out").c_str(), "w", stdout);
#else
#ifndef ONLINE_JUDGE
	freopen("/Users/duxar/Workplace/Xcode Projects/Selectie/Selectie/input", "r", stdin);
		//	freopen("/Users/duxar/Workplace/Xcode Projects/Selectie/Selectie/result", "w", stdout);
#endif
#endif

	int i, from, timefrom, to, timeto, price;

	GetNr(N); GetNr(M); GetNr(K);
	besthere.resize(1 + N, -1);
	arrival.resize(1 + M);
	queries.resize(K);
	ans.resize(K);

	Event depart, arrive, now;
	depart.type = 0;
	arrive.type = 1;
	besthere[1] = 0;

	for (i = 1; i <= M; ++i) {
		GetNr(from); GetNr(timefrom);
		depart.flight = arrive.flight = i;
		depart.where = from;
		depart.timee = timefrom;
		heap.push(depart);

		GetNr(to); GetNr(timeto); GetNr(price);
		arrive.where = to; arrive.timee = timeto;
		arrive.cost = price;
		arrival[i] = arrive;
	}

	for (i = 0; i < K; ++i) {
		GetNr(queries[i].node); GetNr(queries[i].timee);
		queries[i].pos = i;
	}

	sort(ALL(queries), [] (Query a, Query b) -> bool {
		return a.timee < b.timee;
	});
	i = 0;

	while (i < K) {
		if (heap.size() == 0 || queries[i].timee < heap.top().timee) {
			ans[queries[i].pos] = besthere[queries[i].node];
			++i;
		}
		else {
			if (heap.size()) {
				now = heap.top();
				heap.pop();

				LL x = now.where, cost = now.cost;
				if (now.type) {
					if (besthere[x] == -1 || besthere[x] > cost) {
						besthere[x] = cost;
					}
				}
				else {
					if (besthere[x] != -1) {
						arrive = arrival[now.flight];
						arrive.cost += besthere[x];
						heap.push(arrive);
					}
				}
			}
		}
	}

	for (i = 0; i < K; ++i) {
		PutNr(ans[i], '\n');
	}



	return 0;
}
Esempio n. 29
0
File: code.cpp Progetto: sjj118/Code
	void update(){while(B.size()&&A.top()==B.top())A.pop(),B.pop();} 
 // Returns the median of current data stream
 double findMedian() {
     //看中位数是在小的那一半还是大的那一半
     if(large.size() == small.size())    return (double)(large.top() + small.top()) / 2;
     else    return large.size() > small.size() ? large.top() : small.top();
 }