★☆【平衡二叉树】【倍增】会议中心

原创 2012年03月30日 11:35:20
Siruseri政府建造了一座新的会议中心。许多公司对租借会议中心的会堂很感兴趣,他们希望能够在里面举行会议。 对于一个客户而言,仅当在开会时能够独自占用整个会堂,他才会租借会堂。会议中心的销售主管认为:最好的策略应该是将会堂租借给尽可能多的客户。显然,有可能存在不止一种满足要求的策略。 例如下面的例子。总共有4个公司。他们对租借会堂发出了请求,并提出了他们所需占用会堂的起止日期(如下表所示)。
        开始日期  结束日期
公司1   4         9
公司2   9         11
公司3   13        19
公司4   10        17
上例中,最多将会堂租借给两家公司。租借策略分别是租给公司1和公司3,或是公司2和公司3,也可以是公司1和公司4。注意会议中心一天最多租借给一个公司,所以公司1和公司2不能同时租借会议中心,因为他们在第九天重合了。
销售主管为了公平起见,决定按照如下的程序来确定选择何种租借策略:首先,将租借给客户数量最多的策略作为候选,将所有的公司按照他们发出请求的顺序编号。对于候选策略,将策略中的每家公司的编号按升序排列。最后,选出其中字典序最小1的候选策略作为最终的策略。 例中,会堂最终将被租借给公司1和公司3:3个候选策略是{(1,3),(2,3),(1,4)}。而在字典序中(1,3)<(1,4)<(2,3)。 你的任务是帮助销售主管确定应该将会堂租借给哪些公司。
输入格式
输入的第一行有一个整数N,表示发出租借会堂申请的公司的个数。第2到第N+1行每行有2个整数。第i+1行的整数表示第i家公司申请租借的起始和终止日期。对于每个公司的申请,起始日期为不小于1的整数,终止日期为不大于109的整数。
输出格式
输出的第一行应有一个整数M,表示最多可以租借给多少家公司。第二行应
1 字典序指在字典中排列的顺序,如果序列l1是序列l2的前缀,或者对于l1和l2的第一个不同位置j,l1[j]<l2[j],则l1比l2小。
2009 亚太地区信息学奥林匹克竞赛
会议中心(CONVENTION)
第 5 页 共 7 页
列出M个数,表示最终将会堂租借给哪些公司。
数据范围
对于50%的输入,N≤3000。在所有输入中,N≤200000。
输入样例
4
4 9
9 11
13 19
10 17
输出样例
2
1 3
在不要求字典序的情况下,不难求出一个最优解。

而要满足字典序,就必须想出其他的方法。

首先要设计出一个函数max_time(L, R),表示在区间[L, R]中最多能够满足的公司数目。

那么一个区间[L, R]在一个更大的区间[L`, R`]中可行的充要条件为:
max_time(L`, L - 1) + max_time(R + 1, R`) + 1 >= max_time(L`, R`)。(*)

于是问题的关键转化为max_time函数的计算。

再设计一个函数next(i, j)表示在区间[j, R](R为待定常数)中从左到右依次放下i个公司后的能满足条件的最小的R,若不能满足条件,则R = +∞。

用Sprase_Table的思想(即倍增思想)优化next函数,即next(i, j)表示在在区间[j, R](R为待定常数)中从左到右依次放下2^i个公司后的能满足条件的最小的R,若不能满足条件,则R = +∞。

于是max_time函数的求法就解决了。

最后,把最优性问题转化为存在性问题,从1到n枚举每个区间[L, R],在剩余的可行域中找到一个刚好包含当前被枚举的区间[L`, R`]然后用(*)式检验,若可行,则将[L`, R`]删掉并插入两个区间[L`, L - 1], [R + 1, R`]到平衡树中即可。
Accode:

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <set>

using namespace std;
const char fi[] = "convention.in";
const char fo[] = "convention.out";
const int maxN = 200010;
const int MAX = 0x3f3f3f3f;
const int MIN = ~MAX;

struct Seg
{
    int L, R;
    Seg() {}
    Seg(int L, int R): L(L), R(R) {}
    bool operator<(const Seg &b) const
    {return L < b.L || L == b.L && R < b.R;}
};

set <Seg> S;
set <Seg> ::iterator iter;
Seg req[maxN], tmp[maxN], seg[maxN];
int next[20][maxN << 1];
int tab[maxN << 1];
int n, Lim, cnt, logLim;

inline void init_file()
{
    freopen(fi, "r", stdin);
    freopen(fo, "w", stdout);
    return;
}

inline int getint()
{
    int res = 0; char tmp;
    while (!isdigit(tmp = getchar()));
    do res = (res << 3) + (res << 1) + tmp - '0';
    while (isdigit(tmp = getchar()));
    return res;
}

inline bool cmp(const Seg &a, const Seg &b)
{return a.L < b.L || a.L == b.L && a.R > b.R;}

inline int plc(int x)
{
    int L = 0, R = Lim;
    while (L < R + 1)
    {
        int Mid = (L + R) >> 1;
        if (tab[Mid] == x) return Mid + 1;
        if (tab[Mid] > x) R = Mid - 1;
        else L = Mid + 1;
    }
}

inline void readdata()
{
    n = getint();
    for (int i = 0; i < n; ++i)
    {
        int L = getint(), R = getint();
        req[i] = Seg(L, R);
        tab[i << 1] = L;
        tab[(i << 1) + 1] = R;
    }
    return;
}

inline void discrete()
{
    sort(tab, tab + (n << 1));
    tab[Lim++] = tab[0];
    for (int i = 1; i < n << 1; ++i)
    if (tab[i] != tab[i - 1])
        tab[Lim++] = tab[i];
	//离散化过程。
    for (int i = 0; i < n; ++i)
        tmp[i] = req[i] = Seg(plc(req[i].L),
                              plc(req[i].R));
	//重新映射过程。
    sort(tmp, tmp + n, cmp);
    int p = n - 1;
    seg[cnt++] = tmp[n - 1];
    for (int i = n - 2; i > -1; --i)
    if (tmp[i].R < tmp[p].R)
        seg[cnt++] = tmp[p = i];
	//去掉包含其他区间的区间
	//并从按左界从大到小排序。
	//(此时又界也是排好序的。)
    return;
}

inline void next_set()
{
    int p = 0; next[0][Lim + 1] = MAX;
    for (int j = Lim; j; --j)
    if (p < cnt && j == seg[p].L)
        next[0][j] = seg[p++].R + 1;
    else next[0][j] = next[0][j + 1];
    for (int i = 1; ; ++i)
    {
        bool flag = 0;
        next[i][Lim + 1] = MAX;
        for (int k = 1; k < Lim + 1; ++k)
            flag |= (next[i][k] =
                    (next[i - 1][k] == MAX ? MAX
                    : next[i - 1][next[i - 1][k]])) < MAX;
        if (!flag) {logLim = i - 1; break;}
    }
    return;
} //建好next表。

inline int max_time(int L, int R)
{
    if (L >= R) return 0;
    int ans = 0, p = L; ++R;
    for (int j = logLim; j > -1 && p < R; --j)
    if (next[j][p] <= R) //注意这里是小于等于符号。
    {
        p = next[j][p];
        ans += 1 << j;
    }
	//数量从大到小开始放,只要能放下就累加。
    return ans;
}

inline bool judge(int i)
{
    int L = req[i].L, R = req[i].R;
    iter = S.lower_bound(Seg(L, MAX));
	//找到一个左界刚刚大于L的区间并取其前驱。
    if (iter-- == S.begin()) return 0;
	//若无前驱则返回0。
    if (iter -> R < R || iter -> L > L) return 0;
	//若找到的这个区间不能包含被枚举的区间[L, R]则返回0。
    int L1 = iter -> L, R1 = iter -> R;
    if (max_time(L1, L - 1)
        + max_time(R + 1, R1)
        + 1 < max_time(L1, R1))
        return 0;
    S.erase(iter);
    if (L1 < L) S.insert(Seg(L1, L - 1));
    if (R < R1) S.insert(Seg(R + 1, R1));
    return 1;
}

inline void work()
{
    next_set();
    printf("%d\n", max_time(1, Lim));
    S.insert(Seg(1, Lim));
	//首先把初始区域插入到平衡树中。
    for (int i = 0; i < n; ++i)
        if (judge(i)) printf("%d ", i + 1);
    printf("\n");
    return;
}

int main()
{
    init_file();
    readdata();
    discrete();
    work();
    return 0;
}

第二次做:

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <set>

const char fi[] = "convention.in";
const char fo[] = "convention.out";
const int maxN = 200010;
const int MAX = 0x3f3f3f3f, MIN = ~MAX;

struct Seg
{
    int L, R;
    Seg() {}
    Seg(int L, int R): L(L), R(R) {}
    bool operator<(const Seg &b) const
    {return L < b.L || L == b.L && R < b.R;}
};
std::set <Seg> S;
std::set <Seg>::iterator iter;
Seg req[maxN], seg[maxN], tmp[maxN];
int tab[maxN << 1], next[20][maxN << 1];
int n, cnt, Lim = 1, logLim;

void init_file()
{
    freopen(fi, "r", stdin);
    freopen(fo, "w", stdout);
    return;
}

inline int getint()
{
    int res = 0; char tmp;
    while (!isdigit(tmp = getchar()));
    do res = (res << 3) + (res << 1) + tmp - '0';
    while (isdigit(tmp = getchar()));
    return res;
}

void readdata()
{
    n = getint();
    for (int i = 0; i < n; ++i)
    {
        int L = getint(), R = getint();
        req[i] = Seg(L, R);
        tab[i << 1] = L;
        tab[(i << 1) + 1] = R;
    }
    return;
}

int plc(int x)
{
    for (int L = 0, R = Lim - 1; L < R + 1;)
    {
        int Mid = (L + R) >> 1;
        if (x == tab[Mid]) return Mid + 1;
        if (x < tab[Mid]) R = Mid - 1;
        else L = Mid + 1;
    }
}

bool cmp(const Seg &a, const Seg &b)
{return a.R < b.R || a.R == b.R && a.L > b.L;}

void discrete()
{
    std::sort(tab, tab + (n << 1));
    for (int i = 1; i < n << 1; ++i)
    if (tab[i] != tab[i - 1])
        tab[Lim++] = tab[i];
    for (int i = 0; i < n; ++i)
        tmp[i] = req[i] = Seg(plc(req[i].L),
                              plc(req[i].R));
    std::sort(tmp, tmp + n, cmp);
	//这里必须要用一个临时数组,
	//保证左界右界同时单调递增。
    int p = 0; seg[cnt++] = tmp[0];
    for (int i = 1; i < n; ++i)
    if (tmp[i].L > tmp[p].L)
        seg[cnt++] = tmp[p = i];
    return;
}

void next_set()
{
    int p = cnt; next[0][Lim + 1] = MAX;
    for (int j = Lim; j; --j)
    if (p > -1 && j == seg[p - 1].L)
        next[0][j] = seg[--p].R + 1;
    else next[0][j] = next[0][j + 1];
    for (int i = 0; ; ++i)
    {
        bool flag = 0;
        next[i + 1][Lim + 1] = MAX;
        for (int k = 1; k < Lim + 1; ++k)
        {
            if (next[i][k] == MAX)
                next[i + 1][k] = MAX;
            else next[i + 1][k] = next[i][next[i][k]];
            if (next[i + 1][k] < MAX) flag = 1;
        }
        if (!flag) {logLim = i; break;}
    }
    return;
}

int max_time(int L, int R)
{
    if (L > R++) return 0;
    int ans = 0, p = L;
    for (int i = logLim; i > -1 && p < R; --i)
    if (next[i][p] <= R)
    {p = next[i][p]; ans += 1 << i;}
    return ans;
}

bool query(int i)
{
    int L = req[i].L, R = req[i].R;
    iter = S.lower_bound(Seg(L, MAX));
    if (iter-- == S.begin()) return 0;
    if (iter -> L > L || iter -> R < R)
        return 0;
    int L1 = iter -> L, R1 = iter -> R;
    if (max_time(L1, L - 1)
        + max_time(R + 1, R1)
        + 1 < max_time(L1, R1))
	//这里要满足放进去过后不影响总的答案。
        return 0;
    S.erase(iter);
    if (L1 < L) S.insert(Seg(L1, L - 1));
    if (R < R1) S.insert(Seg(R + 1, R1));
    return 1;
}

void work()
{
    printf("%d\n", max_time(1, Lim));
    S.insert(Seg(1, Lim));
    for (int i = 0; i < n; ++i)
    if (query(i))
        printf("%d ", i + 1);
    printf("\n");
    return;
}

int main()
{
    init_file();
    readdata();
    discrete();
    next_set();
    work();
    return 0;
}

相关文章推荐

贪心-会议中心

算法训练 会议中心   时间限制:2.0s   内存限制:512.0MB   会议中心  Siruseri政府建造了一座新的会议中心。许多公司对租借会议中心的会堂很感兴趣,他们希望能够在里面...
  • wximo
  • wximo
  • 2015年04月22日 14:56
  • 2161

蓝桥-ALGO-40-会议中心

ACM模版描述题解离散 + 二分 + 贪心,第一次见这种组合,很有搞头,代码十分有趣,可以好好琢磨琢磨~~~代码#include #include #include #include #inc...
  • f_zyj
  • f_zyj
  • 2017年06月11日 19:48
  • 221

【BZOJ 1178】 [Apio2009]CONVENTION会议中心

思路题+倍增~

InfoComm China 2017 4月12-14日北京国家会议中心盛大举行

InfoComm China 2017展会下周就将盛大展出,今年进入第12届的这场亚太地区专业视听和信息通信技术业界年度重头戏,本年度再度成功地招得了来自全球各地超过300家市场上的龙头企业、厂家和制...

单词博弈Java实现(借鉴“miss若尘”博客中写的解题思路)

单词博弈Java实现 ,已经通过庞果网的用例测试。 代码如下 import java.util.HashMap; public class WordGameFinalTest { p...
  • jh624
  • jh624
  • 2013年12月16日 23:19
  • 3322

单词博弈解题思路,转载“miss若尘”的博客

闲话不多说,直接上原题: 题目详情 甲乙两个人用一个英语单词玩游戏。两个人轮流进行,每个人每次从中删掉任意一个字母,如果剩余的字母序列是严格单调递增的(按字典序a 输入...
  • jh624
  • jh624
  • 2013年12月16日 17:51
  • 1952

平衡二叉树源码

  • 2015年05月14日 10:23
  • 5KB
  • 下载

C语言实现平衡二叉树

  • 2015年08月10日 22:21
  • 7KB
  • 下载

AVL 平衡二叉树旋转方法

1、预备知识定义树(tree)的一种自然的方式是递归的方式。一棵树使一些节点的集合。这个集合可以是空集;若不是空集,则树由称作根(root)的节点 r 以及 0 个或多个非空的(子)树 T1,T2,T...

平衡二叉树

  • 2008年07月02日 20:01
  • 12KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:★☆【平衡二叉树】【倍增】会议中心
举报原因:
原因补充:

(最多只允许输入30个字)