uva 11649 - Home! Sweet Home!(贪心+优先队列）

D	Home! Sweet Home! Input: Standard Input Output: Standard Output

 

Own home is the sweetest place if it is really secured. People build wall around home to make their home more secured. Some pillars are required to make more strong wall. There is a shop named “Home! Sweet Home!”, which sells pillar specially made for building walls. This is really a busy shop. Everyday lot of contractors come, who are responsible for building walls, having a list of homes in their hands. Their list usually contains information of homes specially height of the home and number of pillars required to build that home.

They find pillars are arranged in a row in that shop. Every pillars in row are tagged with heights. Every contractors want to buy some pillars such that they can make walls for all those homes in their list. But unfortunately the shop has some limitation of pillars. So the owner of that shop decides to hire you to write a program for them, which can calculate the number of maximum possible home, for which the contractor can build wall using the pillars in that shop.

 

Note that, a pillar having less height than a home cannot be used to build wall in that home for security purpose.

 

Input

First line of input will contain a number T(1<=T<=200), which indicates the number of test cases. Each test case starts with a line having two integers NP and NH(1<=NP<=100000, 1<=NH<=100000), number of pillars in “Home! Sweet Home!” and number of homes in contractor's list. The next line will contain three integers A, B and C (1 <= A, B, C <= 10000). You can calculate height of the pillars of the shop by this way -

 

PH₁ = C % 10000 + 1

PH₂ = (A * PH₁ + C) % 10000 + 1

PH_i = (A * PH_i-1 + B * PH_i-2 + C) % 10000 + 1, where 3<=i<=NP.

 

Here PH_i represents the height of i^th pillar in the row of the shop.

 

The next line will contain six integers E, F, G, H, I and J. (1 <= E, F, G, H, I, J <= 10000). You can generate the height of the homes and number of pillars required for corresponding homes in the list by this way –

 

HH₁ = G % 10000 + 1

PR₁ = J % 100000 + 1

 

HH_i = (E * HH_i-1 + F * PR_i-1 + G) % 10000 + 1, where 2<=i<=NH

PR_i = (H * PR_i-1 + I * HH_i-1 + J) % 100000 + 1, where 2<=i<=NH

 

Here HH_i represents height of i^th home and PR_i represents number of pillars required to build wall for i^th home.

 

Output

For each test case, output a single line of the form “Case X: N”, where X denotes the case number and N denotes the maximum number home for which it is possible to make a wall.

                

Sample Input                              Output for Sample Input

1 10 4 2 10 19 1 2 1 1 1 1

Case 1: 2

Problem setter: Md. Arifuzzaman Arif , Special Thanks: Jane Alam Jan

 

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;

struct Home{
    int h , r;
    Home(int a = 0 , int b = 0){
        h = a , r = b;
    }
};
vector<Home> home;
vector<int> pillar;
int A , B , C , E , F , G , H , I , J , NP , NH;

bool cmp1(int a , int b){ return a<b;}

bool cmp2(Home h1 , Home h2){
    return h1.h<h2.h;
}

struct cmp{
    bool operator()(Home h1 , Home h2){
        return h1.r>h2.r;
    }
};

void initial(){
    home.clear();
    pillar.clear();
}

void readcase(){
    scanf("%d%d" , &NP , &NH);
    scanf("%d%d%d%d%d%d%d%d%d" , &A , &B , &C , &E , &F , &G , &H , &I , &J);
    pillar.push_back(C % 10000 + 1);
    if(NP >= 2) pillar.push_back((A * pillar[0] + C) % 10000 + 1);
    for(int i = 2; i < NP; i++){
        pillar.push_back((A * pillar[i-1] + B * pillar[i-2] + C) % 10000 + 1);
    }
    home.push_back(Home(G % 10000 + 1 , J % 100000 + 1));
    for(int i = 1; i < NH; i++){
        home.push_back(Home((E * home[i-1].h + F * home[i-1].r + G) % 10000 + 1 , (H * home[i-1].r + I * home[i-1].h + J) % 100000 + 1));
    }
    sort(pillar.begin() , pillar.end() , cmp1);
    sort(home.begin() , home.end() , cmp2);
}

void computing(){
    priority_queue<Home , vector<Home> , cmp> q;
    int h_index = 0 , p_index = 0 , ans = 0;
    while(p_index < NP){
        while(h_index < NH && home[h_index].h <= pillar[p_index]){
        	if(home[h_index].r <= NP-p_index) q.push(home[h_index]);
        	h_index++;
        }
        if(!q.empty()){
            Home thome = q.top();
            q.pop();
            thome.r--;
            if(thome.r <= 0){
            	ans++;
            }
            else q.push(thome);
        }
        p_index++;
    }
    printf("%d\n" , ans);
}

int main(){
    int T;
    scanf("%d" , &T);
    for(int i = 1; i <= T; i++){
        initial();
        readcase();
        printf("Case %d: " , i);
        computing();
    }
    return 0;
}