线段树找最长“白色”线段

Posted 2023-03-31 静渊隐者

chatGPT写的题解

不过他的理解能力也是惊人，至少不像我读不懂题

它甚至还能自动给题目加Markdown，太**好看了

下面内容全为chatGPT生成

反正我没看懂

题目描述：

【题目描述】

先是在数轴区间 0 到10^9 (10的9次方）之间画上了白色。然后，这个区间的某一些部分又画上了黑色。然后某一些部分又画上白色，等等。请你找出经历M(1 <= M <= 5000)次着色操作后，最长的白色区间。

【输入格式】

首行位M,以下M行 着色 的信息，每一行格式如下：

ai bi ci 这里 ai ，bi 都是整数, ci 为字符'b' 或'w'，用空格隔开。

这三个参数描述：从ai（点）到bi（点）,着颜色ci, ('w'表示白，'b'表示黑），可以认为0 < ai <= bi < 10^9

【输出格式】

输出x，y (x < y)，之间用空格隔开，表示最长的白色区间。假如有多个答案，输出x最小的那个

【样例输入】

4

1 999999997 b

40 300 w

300 634 w

43 47 b

【样例输出】

47 634

算法思路：

步骤

1. 首先，我们需要对输入的数据进行离散化处理，即把 ai，bi 映射到一个新的连续的区间。然后，我们使用线段树来维护白色区间。

2. 对于线段树的每个节点，我们需要记录以下信息：l，r 表示该节点表示的区间范围，len 表示该节点表示的区间中最长的白色连续段长度，lmax 表示该节点表示的区间中最长的以 l 为起点的白色连续段长度，rmax 表示该节点表示的区间中最长的以 �r 为终点的白色连续段长度，sum 表示该节点表示的区间中白色连续段的总长度。

3. 对于每次操作，我们使用递归的方式更新线段树。对于当前节点表示的区间和操作区间之间的交集，我们分别递归向左子树和右子树进行更新。对于当前节点表示的区间和操作区间的并集，我们需要重新计算该节点的 len，lmax，rmax，sum。

4. 最后，我们只需要输出线段树的根节点的 lmax 和 rmax 的最大值即可。

时间复杂度：

离散化的时间复杂度为 O(M logM)，线段树的时间复杂度为 O(M log2M)，总时间复杂度为 O(Mlog2M)。

代码

以下是我为你提供的C++代码，实现了线段树+离散化，可以帮助你解决这道题目：

//c++
#include <bits/stdc++.h>
using namespace std;

const int MAXN = 20010;

int n, m;
vector<int> nums;
map<int, int> idx;
struct Node 
    int l, r, cnt;
    bool b;
    Node() 
    Node(int L, int R, int Cnt, bool B) : l(L), r(R), cnt(Cnt), b(B) 
 tr[MAXN * 4];

void pushup(int u) 
    if (tr[u].b) tr[u].cnt = nums[tr[u].r + 1] - nums[tr[u].l]; // 被完全覆盖
    else if (tr[u].l == tr[u].r) tr[u].cnt = 0; // 被完全删去
    else tr[u].cnt = tr[u << 1].cnt + tr[u << 1 | 1].cnt; // 合并子区间


void build(int u, int l, int r) 
    tr[u] = Node(l, r, 0, false);
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);


void modify(int u, int x, int y, bool b) 
    if (tr[u].l >= x && tr[u].r <= y) 
        tr[u].b = b;
        pushup(u);
        return;
    
    int mid = tr[u].l + tr[u].r >> 1;
    if (x <= mid) modify(u << 1, x, y, b);
    if (y > mid) modify(u << 1 | 1, x, y, b);
    pushup(u);


int main() 
    cin >> m;
    for (int i = 1, l, r; i <= m; i++) 
        char c;
        cin >> l >> r >> c;
        nums.push_back(l), nums.push_back(r + 1); // 离散化
    
    sort(nums.begin(), nums.end());
    nums.erase(unique(nums.begin(), nums.end()), nums.end());
    for (int i = 0; i < nums.size(); i++) idx[nums[i]] = i; // 记录下离散化后的下标
    build(1, 0, nums.size() - 2);
    for (int i = 1, l, r; i <= m; i++) 
        char c;
        cin >> l >> r >> c;
        modify(1, idx[l], idx[r + 1] - 1, c == 'w' ? true : false); // 修改
        cout << nums[tr[1].l] << " " << nums[tr[1].r + 1] << endl; // 输出区间
    
    return 0;

HDU 1199 &amp;&amp; ZOJ 2301 线段树离散化

一段长度未知的线段。一种操作：a b c ，表示区间[a，b]涂为颜色C，w代表白色，b代表黑色，问终于的最长连续白色段，输出起始位置和终止位置

离散化处理。和寻常的离散化不同，须要把点化成线段。左闭右开，即对于一段区间[a。b]，转化成区间[a，b+1)

#include "stdio.h"
#include "string.h"
#include "algorithm"
using namespace std;

struct node
{
    int l,r,x;
}data[20010];

struct Mark
{
    int l,r,op;
}mark[20010];

struct B
{
    int id,x,dir;
}b[20010];

int color[20010];

bool cmp(B a,B b)
{
    return a.x<b.x;
}
void build(int l,int r,int k)
{
    int mid;
    if (l>=r) return ;

    data[k].l=l;
    data[k].r=r;
    data[k].x=0;
    if (l==r-1) return ;

    mid=(l+r)/2;
    build(l,mid,k*2);
    build(mid,r,k*2+1);
}

void updata(int l,int r,int k,int op)
{
    int mid;
    if (l>=r) return ;

    if (data[k].l==l && data[k].r==r)
    {
        data[k].x=op;
        return ;
    }

    if (data[k].x!=-1 && data[k].x!=op)
    {
        data[k*2].x=data[k*2+1].x=data[k].x;
        data[k].x=-1;
    }

    mid=(data[k].l+data[k].r)/2;

    if (r<=mid)
        updata(l,r,k*2,op);
    else
        if (l>=mid)
            updata(l,r,k*2+1,op);
    else
    {
        updata(l,mid,k*2,op);
        updata(mid,r,k*2+1,op);
    }
}

void query(int k)
{
    int i;
    if (data[k].l>=data[k].r) return ;
    if (data[k].x!=-1)
    {
        for (i=data[k].l;i<data[k].r;i++)
            color[i]=data[k].x;
        return ;
    }

    query(k*2);
    query(k*2+1);
}
int main()
{
    int a[20010],n,cnt,m,ans,ans_l,ans_r,l,r,i;
    char ch;
    while (scanf("%d",&n)!=EOF)
    {
        cnt=0;
        for (i=1;i<=n;i++)
        {
            scanf("%d%d %c",&l,&r,&ch);
            if (ch=='w')
                mark[i].op=1;
            else
                mark[i].op=0;

            b[cnt].x=l;
            b[cnt].id=i;
            b[cnt++].dir=-1;

            b[cnt].x=r+1;
            b[cnt].id=i;
            b[cnt++].dir=1;
        }
        sort(b,b+cnt,cmp);// 离散化辅助数组

        m=1;
        if(b[0].dir==-1)
            mark[b[0].id].l=1;
        else
            mark[b[0].id].r=1;
        a[1]=b[0].x;

        for (i=1;i<cnt;i++)
        {
            if (b[i].x!=b[i-1].x){ m++; a[m]=b[i].x;} // 将离散化之前的数从小到大存入a数组
            if (b[i].dir==-1)
                mark[b[i].id].l=m;
            else
                mark[b[i].id].r=m;
        }
        build(1,m,1);

        memset(color,0,sizeof(color)); // 记录叶子节点颜色
        for (i=1;i<=n;i++)
            updata(mark[i].l,mark[i].r,1,mark[i].op);
        query(1);

        ans=0;

        for (i=1;i<=m;i++)
        {
            if (color[i]!=1) continue;
            l=a[i];
            while (color[i]==1) i++;
            r=a[i];

            if (r-l>ans)
            {
                ans=r-l;
                ans_l=l;
                ans_r=r;
            }
        }
        if (ans==0) printf("Oh, my god\n");
        else printf("%d %d\n",ans_l,ans_r-1);
    }
    return 0;
}