HDU 6396 Swordsman（优先队列）

Description

战士和 $n$ 个怪物都有 $k$ 种属性，只有战士的属性 $v_1,...,v_k$ 均不小于该怪物的属性 $a_1,...,a_k$ 才能打败这个怪物，然后累加该怪物加成的属性点 $b_1,...,b_k$ ，问战士至多可以打败多少只怪物和打败完这些怪物后战士的属性

Input

第一行一整数 $T$ 表示用例组数，每组用例首先输入两个整数 $n,k$ 表示怪物数量和属性数量，之后输入 $k$ 个整数 $v_1,...,v_k$ 表示战士的初始属性，最后 $n$ 行每行 $2k$ 个整数 $a_{i,1},...,a_{i,k},b_{i,1},...,b_{i,k}$ 表示第 $i$ 个怪物的属性和打败该怪物后的加成

$(1\le n\le 10^5,1\le k\le 5,v_j+\sum\limits_{i=1}^nb_{i,j}\le 10^9)$

Output

输出战士可以打败的怪物数量以及最终战士的属性

Sample Input

1
4 3
7 1 1
5 5 2 6 3 1
24 1 1 1 2 1
0 4 1 5 1 1
6 0 1 5 3 1

Sample Output

3
23 8 4

Solution

用 $k$ 个堆维护所有怪兽的这 $k$ 个属性，首先将所有怪物扔到第一个堆里，从小到大遍历这 $k$ 个堆，只要堆顶怪兽满足被击败的条件就把该怪兽拿出这个堆扔进下一个堆，如果一个怪兽以此经过了这 $k$ 个堆说明这个怪兽完全被击败，计数并修改魔法师的属性，然后继续从第一个堆开始扫，如果没有可以出堆的元素则说明没有可以打败的怪兽，由于每个怪兽只会入堆出堆 $k$ 次，时间复杂度 $O(knlogn)$

Code

#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
namespace fastIO 
{
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror=0;
    inline char nc() 
    {
        static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
        if(p1==pend) 
        {
            p1=buf;
            pend=buf+fread(buf,1,BUF_SIZE,stdin);
            if(pend==p1) 
            {
                IOerror=1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) 
    {
        return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';
    }
    inline void read(int &x) 
    {
        char ch;
        while(blank(ch=nc()));
        if(IOerror)return;
        int sgn=1;
        if(ch=='-')sgn=-1;
        for(x=ch-'0';(ch=nc())>='0'&&ch<='9';x=x*10+ch-'0');
        x=sgn*x;
    }
    #undef BUF_SIZE
};
using namespace fastIO;
typedef pair<int,int>P;
#define maxn 100005
int T,n,k,v[5],a[maxn][5],b[maxn][5];
priority_queue<P>q[5];
int main()
{
    read(T);
    while(T--)
    {
        read(n);read(k);
        for(int i=0;i<k;i++)
        {
            read(v[i]);
            while(!q[i].empty())q[i].pop();
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<k;j++)read(a[i][j]);
            for(int j=0;j<k;j++)read(b[i][j]);
        }
        for(int i=1;i<=n;i++)q[0].push(P(-a[i][0],i));
        int ans=0;
        while(1)
        {
            int flag=0;
            for(int i=0;i<k;i++)
                while(!q[i].empty())
                {
                    P t=q[i].top();
                    int id=t.second,val=-t.first;
                    if(val<=v[i])
                    {
                        flag=1;
                        if(i<k-1)q[i+1].push(P(-a[id][i+1],id));
                        else
                        {
                            ans++;
                            for(int j=0;j<k;j++)v[j]+=b[id][j];
                        }
                        q[i].pop();
                    }
                    else break;
                }
            if(!flag)break; 
        }
        printf("%d\n",ans);
        for(int i=0;i<k;i++)printf("%d%c",v[i],i==k-1?'\n':' ');
    }
    return 0;
}

HDU 6396 Swordsman（优先队列）

猜你喜欢