线段树合集 I

简介

基于个人对线段树的理解，线段树的核心思想就在于离散化和滞后性

hdu 1166 敌兵布阵（入门级）

hdu 1542 Atlantis

将线段离散化，自己一开始利用线段树将沿y坐标的矩阵归并可惜总是wa，最后借鉴了别人的方法

#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 5000;
double MM[MAXN];
double sum;
struct node
{
double len;
int bz;
}data[MAXN<<2];

struct line
{
double x1, x2, y;
int typ;
bool operator < (const line & a) const
{
if (y != a.y)    return y < a.y;
return typ > a.typ;
}
}mLine[MAXN*2];

#define ll (cnt<<1)
#define rr ((cnt<<1)|1)
#define lson l,m,ll
#define rson m,r,rr
#define mid m=(l+r)>>1

void build(int l, int r, int cnt)
{
data[cnt].bz = 0;
data[cnt].len = 0.0;
if (l+1 == r) return;
int mid;
build(lson);
build(rson);
}

void pushUP (int l, int r, int cnt )
{
if (data[cnt].bz)
data[cnt].len = MM[r] - MM[l];
else
{
if (l+1 == r) data[cnt].len = 0.0;
else
data[cnt].len = data[ll].len + data[rr].len;
}
}

void solve(int t, int x1, int x2, int l, int r, int cnt)
{
if (x1 <= l && x2 >= r)
{
data[cnt].bz += t;
pushUP(l, r, cnt);
return;
}
if (l+1 == r) return;
int mid;
if (x1 < m) solve(t, x1, x2, lson);
if (x2 > m) solve(t, x1, x2, rson);
pushUP(l, r, cnt);
}
int n, m, d;
int mfind(double c)
{
int p, q;
p = 0;
q = d - 1;
while( p <= q )
{
int md=(p+q)/2;
if(MM[md]==c)
return md;
if(MM[md]<c)
p=md+1;
else
q=md-1;
}
return -1;
}
int main()
{
int cs = 0;
while (scanf("%d", &n) != EOF && n)
{
m = 0;
sum = 0.0;
double x1, y1, x2, y2;
for (int i = 0; i< n; ++i)
{
scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
if ( (y2-y1)*(x2-x1) == 0.0) continue;
line tp;
tp.x1 = x1; tp.x2 = x2;
tp.y = y1; tp.typ = 1;
MM[m] = x1;
mLine[m++] = tp;

tp.y = y2; tp.typ = -1;
MM[m] = x2;
mLine[m++] = tp;
}
sort(mLine, mLine+m);
sort(MM, MM+m);
d = 1;
for (int i = 1; i< m; ++i)
{
if (MM[i] != MM[d-1])
{
MM[d++] = MM[i];
}
}
build(0, d-1, 1);
for (int i = 0; i< m-1; ++i)
{
int a = mfind(mLine[i].x1);
int b = mfind(mLine[i].x2);
solve(mLine[i].typ, a, b, 0, d-1, 1);
sum += data[1].len * (mLine[i+1].y - mLine[i].y);
}
printf("Test case #%d\n", ++cs);
printf("Total explored area: %.2lf\n\n", sum);
}
return 0;
}

hdu 2795 Billboard

题目有个陷阱，实际上段数等于h和n的最小值就可以

#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
#ifdef __GNUC__
#define LL long long
#else
#define LL __int64
#endif

const int MAXN = 200005;
#define ll (cnt<<1)
#define rr ((cnt<<1)|1)
#define lson l,md,ll
#define rson md+1,r,rr
#define mid md=(l+r)>>1
int h, w, n;
int mxNum[MAXN*3];
void build(int l, int r, int cnt)
{
mxNum[cnt] = w;
if (l == r) return;
int mid;
build(lson);
build(rson);
}

int solve(int a, int l, int r, int cnt)
{
if (l == r)
{
mxNum[cnt] -= a;
return l;
}
int e;
int mid;
if (mxNum[ll] >= a)
{
e = solve(a, lson);
}
else
{
e = solve(a, rson);
}
mxNum[cnt] = max(mxNum[ll], mxNum[rr]);
return e;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
while (scanf("%d%d%d", &h, &w, &n) != EOF)
{
h = min(h, n);
build(1, h, 1);
while (n--)
{
int a, b;
scanf("%d", &a);
if (a > mxNum[1]) b = -1;
else
{
b = solve(a, 1, h, 1);
}
printf("%d\n", b);
}
}
return 0;
}

hdu 3308 LCIS

线段树合并，算是基础上的稍加变化

#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
// hdu 3308
#define ll (rot<<1)
#define rr (ll | 1)
#define mid mm = (l+r)>>1
#define lson l,mm,ll
#define rson mm+1,r,rr
const int MAXN = 100005<<2;
struct mNode
{
int l, r;
int lf, rt, md;
}node[MAXN];
int num[MAXN];
int n, m;
inline void solve(mNode *a, mNode *bl, mNode *br)
{
a->md = max(bl->md, br->md);
int mm = bl->r;
if (num[mm] < num[1+mm])
{
int k = bl->rt + br->lf;
a->md = max(a->md, k);
if (bl->lf == (bl->r-bl->l+1))
{
a->lf = bl->lf + br->lf;
}
else
{
a->lf = bl->lf;
}
if (br->rt == (br->r-mm))
{
a->rt = bl->rt + br->rt;
}
else
{
a->rt = br->rt;
}
}
else
{
a->lf = bl->lf;
a->rt = br->rt;
}
}
void build(int l, int r, int rot)
{
node[rot].l = l;
node[rot].r = r;
if (l == r)
{
node[rot].lf = node[rot].rt= node[rot].md = 1;
return;
}
int mid;
build(lson);
build(rson);
solve(node+rot, node+(ll), node+(rr));
}
void change(int a, int b, int l, int r, int rot)
{
if (l == r)
{
num[l] = b;
node[rot].lf = node[rot].rt= node[rot].md = 1;
return;
}
int mid;
if (a <= mm) change(a, b, lson);
else change(a, b, rson);
solve(node+rot, node+(ll), node+(rr));
}
mNode query(int x, int y, int l, int r, int rot)
{
mNode res, a, b;
if (x <= l && y >= r)
{
return node[rot];
}
int mid;
if (y <= mm)
{
return query(x, y, lson);
}
if (x > mm)
{
return query(x, y, rson);
}
a = query(x, y, lson);
b = query(x, y, rson);
res.l = a.l; res.r = b.r;
solve(&res, &a, &b);
return res;
}
char c[5];
int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
int t;
scanf("%d", &t);
while(t--)
{
scanf("%d%d", &n, &m);
for(int i = 0; i< n; ++i)
{
int a;
scanf("%d", num+i);
}
build(0, n-1, 1);
while (m--)
{
int a, b;
scanf("%s%d%d", c, &a, &b);
if (c[0] == 'U')
{
change(a, b, 0, n-1, 1);
}
else
{
mNode res = query(a, b, 0, n-1, 1);
printf("%d\n", res.md);
}
}
}
return 0;
}

hdu 4027 Can you answer these queries?

 

线段树应用，但题目的突破口是 2^63 最多被开方6次

#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
// hdu 4027
typedef __int64 LL;
#define ll (rot<<1)
#define rr (ll | 1)
#define mid mm = (l+r)>>1
#define lson l,mm,ll
#define rson mm+1,r,rr
const int MAXN = 100005<<2;
struct mNode
{
LL all;
int flg;
}data[MAXN];
LL num[MAXN];
void build(int l, int r, int rot)
{
data[rot].flg = 0;
if (l == r)
{
data[rot].all = num[l];
if (num[l] == 1) data[rot].flg = 1;
return;
}
int mid;
build(lson);
build(rson);
data[rot].all = data[ll].all + data[rr].all;
data[rot].flg = data[ll].flg & data[rr].flg;
}
void add(int x, int y, int l, int r, int rot)
{
if (data[rot].flg) return;
if (l == r)
{
data[rot].all = (LL)sqrt(data[rot].all);
if (data[rot].all == 1) data[rot].flg = 1;
return;
}
int mid;
if (x <= mm) add(x, y, lson);
if (y > mm) add(x, y, rson);
data[rot].all = data[ll].all + data[rr].all;
data[rot].flg = data[ll].flg & data[rr].flg;
}
LL query(int x, int y, int l, int r, int rot)
{
LL sum = 0;
if (x <= l && y >= r )
{
return data[rot].all;
}
int mid;
if (x <= mm) sum += query(x, y, lson);
if (y > mm) sum += query(x, y, rson);
return sum;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
int n, t = 0;
while (scanf("%d", &n) != EOF)
{
printf("Case #%d:\n", ++t);
for (int i = 1; i<= n; ++i)
{
scanf("%I64d", &num[i]);
}
build(1, n, 1);
int k;
scanf("%d", &k);
while (k--)
{
int a, b, c, d, e;
scanf("%d%d%d", &a, &d, &e);
b = min(d, e);
c = max(d, e);
if (a == 0)
{
add(b, c, 1, n, 1);
}
else
{
printf("%I64d\n", query(b, c, 1, n, 1));
}
}
puts("");
}
return 0;
}

hdu 3974 Assign the task

简单题

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
/*
acm.hdu.edu.cn/showproblem.php?pid=3974
*/
const int MAXN = 50005*2;
#define ll (root<<1)
#define rr (ll|1)
#define lson l,m,ll
#define rson m+1,r,rr
#define mid m=(l+r)>>1
int lf[MAXN], rt[MAXN], cnt;
struct Edge
{
int v, next;
}edge[MAXN*2];
int head[MAXN], e, fa[MAXN];
int data[MAXN*2], sz[MAXN*2];
void m_init()
{
memset(head, -1, sizeof head);
memset(fa, -1, sizeof fa);
e = cnt = 0;
}
void add(int u, int v)
{
fa[v] = u;
edge[e].v = v;
edge[e].next = head[u];
head[u] = e++;
}
void build(int l, int r, int root)
{
data[root] = -1;
sz[root] = 0;
if (l == r) return;
int mid;
build(lson); build(rson);
}
void pushDown(int root)
{
if (!sz[root]) return;
sz[root] = 0;
data[ll] = data[rr] = data[root];
sz[ll] = sz[rr] = 1;
}
void change(int c, int x, int y, int l, int r, int root)
{
if (x <= l && y >= r)
{
data[root] = c; sz[root] = 1;
return;
}
pushDown(root);
int mid;
if (x <= m) change(c,x,y,lson);
if (y > m) change(c,x,y,rson);
}
int query(int x, int l, int r, int root)
{
if (l == r) return data[root];
pushDown(root);
int mid;
if (x <= m) return query(x,lson);
if (x > m) return query(x,rson);
}
void dfs(int u)
{
lf[u] = cnt++;
for (int i= head[u]; ~i; i = edge[i].next)
{
dfs(edge[i].v);
}
rt[u] = cnt-1;
}
char str[3];
int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
int t, cs = 0;
int n, m;
scanf("%d", &t);
while (t--)
{
printf("Case #%d:\n", ++cs);
m_init();
scanf("%d", &n);
for (int i = 1; i< n; ++i)
{
int v, u;
scanf("%d%d", &v, &u);
add(u,v);
}
int k;
for (int i = 1; i<= n; ++i)
{
if (fa[i] == -1)
{
k = i;
break;
}
}
dfs(k);
build(0, cnt-1, 1);
scanf("%d", &m);
while (m--)
{
int a, b;
scanf("%s", str);
if (str[0] == 'C')
{
scanf("%d", &a);
printf("%d\n", query(lf[a],0,cnt-1,1));
}
else
{
scanf("%d%d", &a, &b);
change(b, lf[a], rt[a], 0, cnt-1, 1);
}
}
}
return 0;
}