269D

扫描线+dp

先对坐标排序，然后·用set维护端点，每次插入左端点，扫描到右端点时删除。每次考虑新插入时分割了哪两个木板，自己分别连边，再删除原来的边，最后dp（好像得维护used，有环）

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int N = , inf = ;
struct data {
    int l, r, h;
    data(int l = , int r = , int h = ) : l(l), r(r), h(h) {}
} ed[N];
int n, t, cnt;
int dp[N], used[N];
PII e[N];
set<PII> s, m;
vector<PII> G[N];
void dfs(int u)
{
    if(dp[u] == inf || used[u]) return;
    used[u] = ;
    for(int i = ; i < G[u].size(); ++i)
    {
        PII x = G[u][i];
        int v = x.first, w = x.second;
        dfs(v);
        dp[u] = max(dp[u], min(dp[v], w));
    }
}
int main()
{
    scanf("%d%d", &n, &t);
    for(int i = ; i <= n; ++i)
    {
        int h, l, r; scanf("%d%d%d", &h, &l, &r);
        ed[i] = data(l, r, h);
        e[++cnt] = make_pair(l, i);
        e[++cnt] = make_pair(r, -i);
    }
    sort(e + , e + cnt + );
    ed[n + ] = data(-inf, inf, );
    ed[n + ] = data(-inf, inf, t);
    s.insert(make_pair(, n + ));
    s.insert(make_pair(t, n + ));
    for(int i = ; i <= cnt; ++i)
    {
        int x = e[i].second;
        if(x < )
        {
            s.erase(make_pair(ed[-x].h, -x));
            continue;
        }
        PII t = make_pair(ed[x].h, x);
        set<PII> :: iterator it = s.lower_bound(t);
        PII up = *it;
        --it;
        PII low = *it;
        m.erase(make_pair(up.second, low.second));
        m.insert(make_pair(up.second, x));
        m.insert(make_pair(x, low.second));
        s.insert(t);
    }
    for(set<PII> :: iterator it = m.begin(); it != m.end(); ++it)
    {
        PII x = *it;
        int len = min(ed[x.second].r, ed[x.first].r) - max(ed[x.second].l, ed[x.first].l);
        G[x.second].push_back(make_pair(x.first, len));
    }
    dp[n + ] = inf;
    dfs(n + );
    printf("%d\n", dp[n + ]);
    return ;
}

线段树维护+dp

这个方法好恶心，调了好长时间，边界搞错。

先离散化坐标，然后按高度排序，正反两次建边。但是一定要注意，边界很恶心，有可能出现1-2,2-3这样的，这样是不相交的。所以右端点要-1就避免了这种情况，因为如果原先只有1单位重合，那么现在不相交了。如果有1单位以上重合，那么现在还是相交的。

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int M = , inf = ;
int n, T, N;
vector<PII> G[M];
vector<int> v;
map<int, int> mp, mir;
int dp[M], used[M];
struct data {
    int l, r, h;
} a[M];
struct seg {
    int tree[M << ], tag[M << ];
    void pushdown(int x)
    {
        if(!tag[x]) return;
        tag[x << ] = tag[x];
        tag[x <<  | ] = tag[x];
        tree[x << ] = tag[x];
        tree[x <<  | ] = tag[x];
        tag[x] = ;
    }
    void update(int l, int r, int x, int a, int b, int c)
    {
        if(l > b || r < a) return;
        if(l >= a && r <= b)
        {
            tree[x] = tag[x] = c;
            return;
        }
        pushdown(x);
        int mid = (l + r) >> ;
        update(l, mid, x << , a, b, c);
        update(mid + , r, x <<  | , a, b, c);
        tree[x] = max(tree[x << ], tree[x <<  | ]);
    }
    int query(int l, int r, int x, int a, int b)
    {
        if(l > b || r < a) return ;
        if(l >= a && r <= b) return tree[x];
        pushdown(x);
        int mid = (l + r) >> ;
        return max(query(l, mid, x << , a, b), query(mid + , r, x <<  | , a, b));
    }
} t;
void construct(int N, bool flag)
{
    memset(t.tree, , sizeof(t.tree));
    memset(t.tag, , sizeof(t.tag));
    for(int i = ; i < n; ++i)
    {
        int k = t.query(, N, , a[i].l, a[i].l);
        int low = max(a[i].l, a[k].l), high = min(a[i].r, a[k].r), len = mir[high] - mir[low];
        int tt = t.query(, N, , low, high - );
         if(tt == k && tt)
         {
            if(!flag) G[k].push_back(make_pair(i, len));
            else G[n - i + ].push_back(make_pair(n - k + , len));
        }
        k = t.query(, N, , a[i].r - , a[i].r - );
        low = max(a[i].l, a[k].l), high = min(a[i].r, a[k].r), len = mir[high] - mir[low];
        tt = t.query(, N, , low, high - );
        if(tt == k && tt)
        {
            if(!flag) G[k].push_back(make_pair(i, len));
            else G[n - i + ].push_back(make_pair(n - k + , len));
        }
        t.update(, N, , a[i].l, a[i].r - , i);
    }
}
void dfs(int u)
{
    if(used[u] || dp[u] == inf) return;
    used[u] = ;
    for(int i = ; i < G[u].size(); ++i)
    {
        PII x = G[u][i];
        int v = x.first, w = x.second;
        dfs(v);
        dp[u] = max(dp[u], min(dp[v], w));
    }
}
bool cp(data x, data y)
{
    return x.h == y.h ? x.l < y.l : x.h < y.h;
}
int main()
{
    scanf("%d%d", &n, &T);
    a[].h = ;
    a[n + ].h = T;
    a[].l = a[n + ].l = -inf;
    a[].r = a[n + ].r = inf;
    v.push_back(inf);
    v.push_back(-inf);
    for(int i = ; i <= n; ++i)
    {
        scanf("%d%d%d", &a[i + ].h, &a[i + ].l, &a[i + ].r);
        v.push_back(a[i + ].l);
        v.push_back(a[i + ].r);
    }
    sort(v.begin(), v.end());
    v.erase(unique(v.begin(), v.end()), v.end());
    N = v.size();
    for(int i = ; i < v.size(); ++i)
    {
        mp[v[i]] = i + ;
        mir[i + ] = v[i];
    }
    n += ;
    for(int i = ; i <= n; ++i)
    {
        a[i].l = mp[a[i].l];
        a[i].r = mp[a[i].r];
    }
    sort(a + , a + n + , cp);
    construct(N, false);
    reverse(a + , a + n + );
    construct(N, true);
    dp[n] = inf;
    dfs();
    printf("%d\n", dp[]);
    return ;
}