Beautiful People (zoj 2319)

Beautiful People (zoj 2319)

The most prestigious sports club in one city has exactly N members. Each of its members is strong and beautiful. More precisely, i-th member of this club (members being numbered by the time they entered the club) has strength Si and beauty Bi. Since this is a very prestigious club, its members are very rich and therefore extraordinary people, so they often extremely hate each other. Strictly speaking, i-th member of the club Mr X hates j-th member of the club Mr Y if Si <= Sj and Bi >= Bj or if Si >= Sj and Bi <= Bj (if both properties of Mr X are greater then corresponding properties of Mr Y, he doesn??t even notice him, on the other hand, if both of his properties are less, he respects Mr Y very much).
To celebrate a new 2005 year, the administration of the club is planning to organize a party. However they are afraid that if two people who hate each other would simultaneouly attend the party, after a drink or two they would start a fight. So no two people who hate each other should be invited. On the other hand, to keep the club prestige at the apropriate level, administration wants to invite as many people as possible.
Being the only one among administration who is not afraid of touching a computer, you are to write a program which would find out whom to invite to the party.
This problem contains multiple test cases!
The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.
The output format consists of N output blocks. There is a blank line between output blocks.
Input
The first line of the input file contains integer N - the number of members of the club. (2 <= N <= 100 000). Next N lines contain two numbers each - Si and Bi respectively (1 <= Si, Bi <= 109).
Output
On the first line of the output file print the maximum number of the people that can be invited to the party. On the second line output N integers - numbers of members to be invited in arbitrary order. If several solutions exist, output any one.
Sample Input

1

 4
 1 1
 1 2
 2 1
 2 2

Sample Output
2
 1 4


题意：这道题的是意思是，给你t个测试数据，每个测试数据有n个人，其中每个人都有力量值Si和颜值Bi,只有当Si<=Sj&&Bi<=Bj，或者Si>=Sj&&Bi>=Bj时，才能去参加party。输出最多参加的人数，和其所在的下标，其中，下标是从1开始的。

题解：这道题是单调递增最长子序列，让S单调递增排序，当Si==Sj的时候，让B单调递减排序。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<map>
#include<queue>
using namespace std;
const int maxn=100001;
int dp[maxn];//表示在这个子序列中以i结尾的，最小的B值
int mark[maxn];//表示以i结尾的子序列的长度
struct node{
    int s,b;
    int id;
    bool operator<(const node &x) const{
    if(s==x.s)
        return x.b<b;
    return s<x.s;
    }
}a[maxn];

int main()
{
    int t,n,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&a[i].s,&a[i].b);
            a[i].id=i;
        }
        sort(a+1,a+n+1);
         int max_len = 0;
        dp[++max_len] = a[1].b;
        mark[1] = max_len;
        for(int i = 2; i <= n; i++) {
            if(dp[max_len] < a[i].b) {
                dp[++max_len] = a[i].b;
                mark[i] = max_len;
            }
            else {
                int k = lower_bound(dp+1, dp+1+max_len, a[i].b) - dp;
                dp[k] = a[i].b;
                mark[i] = k;
            }
        }
        printf("%d\n", max_len);
        for(int i = n; i >= 1; i--) {
            if(mark[i] == max_len) {
                printf("%d", a[i].id);
                if(max_len > 1) printf(" ");
                max_len--;
            }

    } printf("\n");
    }
    return 0;
}

STL中关于二分查找的函数有三个lower_bound 、upper_bound 、binary_search 。这三个函数都运用于有序区间（当然这也是运用二分查找的前提），下面记录一下这两个函数。

ForwardIter lower_bound(ForwardIter first, ForwardIter last,const _Tp& val)算法返回一个非递减序列[first, last)中的第一个大于等于值val的位置。

ForwardIter upper_bound(ForwardIter first, ForwardIter last, const _Tp& val)算法返回一个非递减序列[first, last)中的第一个大于值val的位置。

注意last的位置，是要查找末尾的下一个地址，是开区间。

lower_bound和upper_bound如下图所示：

lower_bound
//二分的区间是a[]数组里的[l,r] 找的是tar
int lowbou(int a[],int l,int r,int tar)
{
    while(l<=r){
        int mid=(l+r)/2;
        if (a[mid]<tar) l=mid+1;
        else r=mid-1;
    }
    return l;
}


upper_bound
//二分的区间是a[]数组里的[l,r] 找的是tar
int uppbou(int a[],int l,int r,int tar)
{
    while(l<=r){
        int mid=(l+r)/2;
        if (a[mid]<=tar) l=mid+1;
        else r=mid-1;
    }
    return l;
}

-----------------------------------------------------------------------------------

#include<bits/stdc++.h>
using namespace std;
int a[100];
//二分的区间是a[]数组里的[l,r] 找的是tar
int lowbou(int l,int r,int tar)
{
    while(l<=r){
        int mid=(l+r)/2;
        if (a[mid]<tar) l=mid+1;
        else r=mid-1;
    }
    return l;
}
int main()
{
    int n,i;
    scanf("%d",&n);
    for(i=0;i<n;i++)
        scanf("%d",&a[i]);
    printf("%d\n",lowbou(1,10,11));//（一）
    //(二)printf("%d\n",lowbou(1,10,8));
    return 0;
}


/*
(一)
15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
10
Process returned 0 (0x0)   execution time : 11.464 s
Press any key to continue.
(二)
15
1 2 3 4 5  6 7 8 9 10 11 12 13 14 15
7
Process returned 0 (0x0)   execution time : 20.987 s
Press any key to continue.
*/