hdu517 Triple

Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 160    Accepted Submission(s): 72

Problem Description

Given the finite multi-set A of n pairs
of integers, an another finite multi-set B of m triples
of integers, we define the product of A and B as
a multi-set

C=A∗B={⟨a,c,d⟩∣⟨a,b⟩∈A, ⟨c,d,e⟩∈B and b=e}

For each ⟨a,b,c⟩∈C,
its BETTER set is defined as

BETTERC(⟨a,b,c⟩)={⟨u,v,w⟩∈C∣⟨u,v,w⟩≠⟨a,b,c⟩, u≥a, v≥b, w≥c}

As a \textbf{multi-set} of triples, we define the TOP subset (as a multi-set as well) of C,
denoted by TOP(C),
as

TOP(C)={⟨a,b,c⟩∈C∣BETTERC(⟨a,b,c⟩)=∅}

You need to compute the size of TOP(C).

 

Input

The input contains several test cases. The first line of the input is a single integer t (1≤t≤10) which
is the number of test case. Then t test
cases follow.

Each test case contains three lines. The first line contains two integers n (1≤n≤105) and m (1≤m≤105) corresponding
to the size of A and B respectively.

The second line contains 2×n nonnegative
integers

a1,b1,a2,b2,⋯,an,bn

which describe the multi-set A,
where 1≤ai,bi≤105.

The third line contains 3×m nonnegative
integers

c1,d1,e1,c2,d2,e3,⋯,cm,dm,em

corresponding to the m triples
of integers in B,
where 1≤ci,di≤103 and 1≤ei≤105.

 

Output

For each test case, you should output the size of set TOP(C).

 

Sample Input

2
5 9
1 1 2 2 3 3 3 3 4 2
1 4 1 2 2 1 4 1 1 1 3 2 3 2 2 4 1 2 2 4 3 3 2 3 4 1 3
3 4
2 7 2 7 2 7
1 4 7 2 3 7 3 2 7 4 1 7

 

Sample Output

Case #1: 5
Case #2: 12

思路：这题可以用二维树状数组做，先对二元组按y关键字升序排列，对三元组按z关键字升序排列，找出二元组中y相同的情况下最大的x及其个数，然后依次乘上三元组形成新的三元组并放入map中，用map记录三元组即其个数，便于后面统计方案。然后删去不合法的三元组，可以先对其按x，y，z一二三关键字降序排列，然后依次循环，这样首先保证x是递减的，然后如果在它右上方有点，那么这个点就要删除（即y,z都大于等于它），可以用树状数组实现。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
#define inf 99999999
#define maxn 100050
int first[maxn],last[maxn],cnt[maxn],maxnum[maxn];
struct node1{
    int x,y;
}a[maxn];

struct node2{
    int x,y,z;
}c[maxn];

bool cmp(node1 a,node1 b){
    if(a.y==b.y)return a.x>b.x;
    return a.y<b.y;
}
bool cmp1(node2 a,node2 b){
    return a.z<b.z;
}
struct node{
    int x,y,z;
}temp,temp2;

bool operator<(node a,node b){
    if(a.x==b.x){
        if(a.y==b.y)return a.z>b.z;
        return a.y>b.y;
    }
    return a.x>b.x;
}

map<node,int>mp;
map<node,int>::iterator it;

int b[1005][1005],pan[1006][1006];
int lowbit(int x){
    return x&(-x);
}
void update(int x,int y,int num)
{
    int i,j;
    for(i=x;i<=1003;i+=lowbit(i)){
        for(j=y;j<=1003;j+=lowbit(j)){
            b[i][j]+=num;
        }
    }
}

int getsum(int x,int y)
{
    int num=0,i,j;
    for(i=x;i>0;i-=lowbit(i)){
        for(j=y;j>0;j-=lowbit(j)){
            num+=b[i][j];
        }
    }
    return num;
}

int cal(int x,int y){
    return getsum(1003,1003)-getsum(1003,y-1)-getsum(x-1,1003)+getsum(x-1,y-1);
}

int main()
{
    int n,m,i,j,T,d,e,f,t,maxx,num,cas=0;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;i++){
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        sort(a+1,a+n+1,cmp);
        for(i=1;i<=m;i++){
            scanf("%d%d%d",&c[i].x,&c[i].y,&c[i].z);
        }
        sort(c+1,c+m+1,cmp1);
        memset(first,0,sizeof(first));
        memset(last,0,sizeof(last));
        t=c[1].z;
        first[t]=1;
        c[m+1].z=-1;
        for(i=2;i<=m+1;i++){
            if(c[i].z!=t ){
                last[t]=i-1;
                t=c[i].z;
                first[t]=i;
            }
        }
        memset(maxnum,-1,sizeof(maxnum));
        memset(cnt,0,sizeof(cnt));
        for(i=1;i<=n;i++){
            if(maxnum[a[i].y ]==-1  ){
                maxnum[a[i].y ]=a[i].x;
                cnt[a[i].y ]=1;
            }
            else{
                if(maxnum[a[i].y ]<a[i].x){
                    maxnum[a[i].y ]=a[i].x;
                    cnt[a[i].y ]=1;
                }
                else if(maxnum[a[i].y ]==a[i].x){
                    cnt[a[i].y ]++;

                }

            }

        }
        mp.clear();
        for(i=1;i<=10000;i++){
            if(maxnum[i ]!=-1  && first[i ]!=0      ){
                for(j=first[i ];j<=last[i ];j++){
                    temp.x=maxnum[i];temp.y=c[j].x;temp.z=c[j].y;
                    mp[temp]+=cnt[i];
                }
            }
        }
        memset(b,0,sizeof(b));
        memset(pan,0,sizeof(pan));
        int ans=0;
        for(it=mp.begin();it!=mp.end();it++){
            temp=it->first;
            int y=temp.y;
            int z=temp.z;
            if(pan[y][z]==0 && cal(y,z)==0){
                ans+=it->second;
            }
            pan[y][z]=1;
            update(y,z,1);
        }
        cas++;
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;
}