]]>
F[i][j]=max{F[i1][j1] - (sA[i-1]-sA[i1])2 - (sB[j-1]-sB[j1])2} + A[i]*B[j], 0<=i1<i, 0<=j1<j
对这个式子进行化Q?br />F[i][j]=max{F[i1][j1] - sA[i1]2 + 2*sA[i-1]*sA[i1] - sB[j1]2 + 2*sB[j-1]*sB[j1]}+A[i]*B[j]-sA[i-1]2-sB[j-1]2
对于一l的情况Q很Ҏ处理——中间是一条直U，然而这是二l的Q对于这U?D/2D的DP方程Q要优化到O(N2)U别Q需要两步?br />注意到决{式中除了F[i1][j1]外，其它部分都要么只与i1有关Q要么只与j1有关。因此，可以把阶Di的各个状态作Z个整体，在之前得出的各个F[i][j]中，对于相同的jQ找到对于目前的iQ最优的那个决策——注意Q对于相同的j1Q里面所有与j1有关的东襉K可以先不考虑了，只考虑(F[i1][j1] - sA[i1]2 + 2*sA[i-1]*sA[i1])对于目前i的最优决{。这一步可以在q些直线形成的上凸壳中找刎ͼ且满_{单调性，可以用一个栈处理Q斜率优化）。然后，这些最优决{以j变量再组成一些直U，用栈l护它们的上凸壳Q对于每个jQ找到最优值即可?br />注意事项Q在栈中删除直线的时候，如果之前的最优决{是q个被删掉的直线Q则要将最优决{先|ؓ不存在，然后再插入新直线后设为新直线。另外，要特别注意^行的情况?br />
?】LCIS
l典问题Q利用上面的分步优化思想Q很Ҏ用线D|得到一个O(N2logN)的做法?br />
??a title="[SCOI2010]股票交易 " >[SCOI2010]股票交易
F[i][j]=max{F[i-1][j], max{F[i-W-1][j-a]-A*a, F[i-W-1][j+b]+b*B}}, j<=maxP, 1<=a<=maxA, 1<=b<=maxB
注意对于相同的jQ计方法是一LQ且是一条直U（׃有范围所以其实是U段Q?br />所以，计算阶段iӞ可以?i-W-1)阶段所有的决策当成U段插入Q这些线D늚斜率都相{，因此比较好维护，只需要判断边界即可?br />
注意QNOI2011的show虽然也符合对于相同的j计算Ҏ一P但它׃能优化，因ؓ它的决策是不q箋且无规律的，没有M几何性质。因此，它只能用O(N3)的算法计出所有状态?br />
]]>
求图的s-tWK短简单\问题Q若有长度相同的Q字典序的优先?br />
首先Q由于是单\Q所?a title="A*" href="http://www.shnenglu.com/MatoNo1/archive/2011/05/01/145456.html">A*是不能做的，因ؓ有可能有两条s-iQi为某个中间点Q\P1和P2QP1比P2短，但由于P1到达的顶点与P2不同Q导致最l沿P1到达t的\径长度长于沿P2到达t的（甚至有可能沿P1ҎC了tQ。然后，如果直接用DFSQ由于要求的是第K优解Q而不是最优解Q所以不能用最优性剪枝（包括分支限界Q，因此专门为最优性剪枝服务的“改变搜烦序”技巧也不能使用了，因此Q能够用的只有可行性剪枝，而本题的数据范围使得q种法必然TLE?br />
正解是一U由q代加深思想扩展得到?#8220;q代变优”DFS。设|一个\径长度上限ZQ搜索s到t的所有简单\Q在搜烦q程中，遇到长度大于Z的\径就停止Q剪枝）Q然后，若得到\径不K条，则增加Z的|重新开始搜索，直到得到的\径L大于{于K条ؓ止。这里可以进行启发式的优化，设g[i]为点i到t的最短\长度Q则搜烦q程中，假设目前搜到点iQ则Q目前\径长?g[i]Q是Ҏ条\径最短长度的乐观估计Q如果这个Dq了ZQ就可以剪枝Q但在剪枝之前要Cq个过了Z的启发|取其中最的作ؓ下一ơP代的Z倹{那么对于字典序肿么办？可以在搜索过E中Q强制先搜编号小的结点，q样得到的s-t路径必然是字典序递增的。另外只要求出第K条\径，搜烦可以终止，因ؓҎ证明Q题目要求的WK短的路径一定已l求出来了（只不q不一定是最后一条而已Q，扑ֈ卛_。此外，在搜索过E中不要忘了可行性剪枝，是如果沿目前搜到的路径已经C了t了，剪枝?br />
“q代变优”DFSQ就是设|一个解的评价值的上限Q最|或下限（最大|Q在搜烦q程中，如果实际评h|或者启发|如果可以加启发式优化的话Q越q这个限Ӟ则剪枝。在一ơ搜索后Q如果没有得到符合要求的解，将该限制?span style="color: red">设ؓ本次搜烦q程中越?#8220;?#8221;得最q的那个?/strong>Q重新开始搜索，直到扑ֈ所需要的解或?span style="color: red">发现无解Q如果一ơ搜索中没有发生界Q却仍然没有扑ֈ解）为止。其应用主要体现在两个方面：Q?Q搜索树q深甚至无限深，但所需求的那个解却不深的情况；Q?Q求WK优解的情c?br />
代码Q?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 51, MAXK = 201, MAXM = 3000, INF = ~0U >> 2;
struct edge {
int a, b, w, pre, next;
} E[MAXM + MAXN], E0[MAXM + MAXN];
struct edge0 {
int a, b, w;
bool operator< (edge0 e0) const {return b < e0.b;}
} _E[MAXM];
int n, m, s, t, K, dist[MAXN], Q[MAXN + 1];
int Z, Z0, vst0[MAXN], _FL, len0, X00[MAXN], No, len[MAXK], X0[MAXK][MAXN], sum0[MAXK], reslen, res[MAXN];
bool vst[MAXN], res_ex = 0;
void init_d()
{
re(i, n) E[i].pre = E[i].next = E0[i].pre = E0[i].next = i; m = n;
}
void add_edge(int a, int b, int w)
{
E[m].a = a; E[m].b = b; E[m].w = w; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m;
E0[m].a = b; E0[m].b = a; E0[m].w = w; E0[m].pre = E0[b].pre; E0[m].next = b; E0[b].pre = m; E0[E0[m].pre].next = m++;
}
void init()
{
int m0; scanf("%d%d%d%d%d", &n, &m0, &K, &s, &t); init_d(); s--; t--;
re(i, m0) {scanf("%d%d%d", &_E[i].a, &_E[i].b, &_E[i].w); _E[i].a--; _E[i].b--;}
sort(_E, _E + m0);
re(i, m0) add_edge(_E[i].a, _E[i].b, _E[i].w);
}
void prepare()
{
re(i, n) {vst[i] = 0; dist[i] = INF;} vst[t] = 1; dist[t] = 0; Q[0] = t;
int x, y, d0, d1;
for (int front=0, rear=0; !(!front && rear==n || front==rear+1); front==n ? front=0 : front++) {
x = Q[front]; d0 = dist[x];
for (int p=E0[x].next; p != x; p=E0[p].next) {
y = E0[p].b; d1 = d0 + E0[p].w;
if (d1 < dist[y]) {
dist[y] = d1;
if (!vst[y]) {vst[y] = 1; Q[rear==n ? rear=0 : ++rear] = y;}
}
}
vst[x] = 0;
}
}
void dfs(int x, int sum)
{
if (x == t) {
if (sum <= Z) {sum0[No] = sum; len[No] = len0; re(i, len0) X0[No][i] = X00[i]; No++; if (No == K) res_ex = 1;}
else if (sum < Z0) Z0 = sum;
return;
} else {
int h0 = sum + dist[x];
if (h0 > Z) {if (h0 < Z0) Z0 = h0; return;}
vst0[x] = ++_FL; Q[0] = x; int _x, _y;
for (int front=0, rear=0; front<=rear; front++) {
_x = Q[front];
for (int p=E[_x].next; p != _x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y] && vst0[_y] != _FL) {vst0[_y] = _FL; Q[++rear] = _y;}
}
}
if (vst0[t] != _FL) return;
for (int p=E[x].next; p != x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y]) {vst[_y] = 1; X00[len0++] = _y; dfs(_y, sum + E[p].w); if (res_ex) return; else {len0--; vst[_y] = 0;}}
}
}
}
void solve()
{
Z = dist[s]; int No0 = 0; _FL = 0;
while (1) {
Z0 = INF; No = 0; re(i, n) {vst[i] = 0; vst0[i] = 0;}
vst[s] = 1; len0 = 1; X00[0] = s; dfs(s, 0);
if (res_ex) {
No0 = K - No0;
re(i, K) if (sum0[i] == Z) {No0--; if (!No0) {reslen = len[i]; re(j, len[i]) res[j] = X0[i][j];}}
break;
} else if (Z0 == INF) break; else {No0 = No; Z = Z0;}
}
}
void pri()
{
if (res_ex) {
printf("%d", res[0] + 1);
re2(i, 1, reslen) printf("-%d", res[i] + 1);
puts("");
} else puts("No");
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 51, MAXK = 201, MAXM = 3000, INF = ~0U >> 2;
struct edge {
int a, b, w, pre, next;
} E[MAXM + MAXN], E0[MAXM + MAXN];
struct edge0 {
int a, b, w;
bool operator< (edge0 e0) const {return b < e0.b;}
} _E[MAXM];
int n, m, s, t, K, dist[MAXN], Q[MAXN + 1];
int Z, Z0, vst0[MAXN], _FL, len0, X00[MAXN], No, len[MAXK], X0[MAXK][MAXN], sum0[MAXK], reslen, res[MAXN];
bool vst[MAXN], res_ex = 0;
void init_d()
{
re(i, n) E[i].pre = E[i].next = E0[i].pre = E0[i].next = i; m = n;
}
void add_edge(int a, int b, int w)
{
E[m].a = a; E[m].b = b; E[m].w = w; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m;
E0[m].a = b; E0[m].b = a; E0[m].w = w; E0[m].pre = E0[b].pre; E0[m].next = b; E0[b].pre = m; E0[E0[m].pre].next = m++;
}
void init()
{
int m0; scanf("%d%d%d%d%d", &n, &m0, &K, &s, &t); init_d(); s--; t--;
re(i, m0) {scanf("%d%d%d", &_E[i].a, &_E[i].b, &_E[i].w); _E[i].a--; _E[i].b--;}
sort(_E, _E + m0);
re(i, m0) add_edge(_E[i].a, _E[i].b, _E[i].w);
}
void prepare()
{
re(i, n) {vst[i] = 0; dist[i] = INF;} vst[t] = 1; dist[t] = 0; Q[0] = t;
int x, y, d0, d1;
for (int front=0, rear=0; !(!front && rear==n || front==rear+1); front==n ? front=0 : front++) {
x = Q[front]; d0 = dist[x];
for (int p=E0[x].next; p != x; p=E0[p].next) {
y = E0[p].b; d1 = d0 + E0[p].w;
if (d1 < dist[y]) {
dist[y] = d1;
if (!vst[y]) {vst[y] = 1; Q[rear==n ? rear=0 : ++rear] = y;}
}
}
vst[x] = 0;
}
}
void dfs(int x, int sum)
{
if (x == t) {
if (sum <= Z) {sum0[No] = sum; len[No] = len0; re(i, len0) X0[No][i] = X00[i]; No++; if (No == K) res_ex = 1;}
else if (sum < Z0) Z0 = sum;
return;
} else {
int h0 = sum + dist[x];
if (h0 > Z) {if (h0 < Z0) Z0 = h0; return;}
vst0[x] = ++_FL; Q[0] = x; int _x, _y;
for (int front=0, rear=0; front<=rear; front++) {
_x = Q[front];
for (int p=E[_x].next; p != _x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y] && vst0[_y] != _FL) {vst0[_y] = _FL; Q[++rear] = _y;}
}
}
if (vst0[t] != _FL) return;
for (int p=E[x].next; p != x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y]) {vst[_y] = 1; X00[len0++] = _y; dfs(_y, sum + E[p].w); if (res_ex) return; else {len0--; vst[_y] = 0;}}
}
}
}
void solve()
{
Z = dist[s]; int No0 = 0; _FL = 0;
while (1) {
Z0 = INF; No = 0; re(i, n) {vst[i] = 0; vst0[i] = 0;}
vst[s] = 1; len0 = 1; X00[0] = s; dfs(s, 0);
if (res_ex) {
No0 = K - No0;
re(i, K) if (sum0[i] == Z) {No0--; if (!No0) {reslen = len[i]; re(j, len[i]) res[j] = X0[i][j];}}
break;
} else if (Z0 == INF) break; else {No0 = No; Z = Z0;}
}
}
void pri()
{
if (res_ex) {
printf("%d", res[0] + 1);
re2(i, 1, reslen) printf("-%d", res[i] + 1);
puts("");
} else puts("No");
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
]]>
预处理：设F[i]Zi开头的最长上升序列的长度Q怎么求不用说了吧?#8230;…
假设目前需要求长度为M的、标号字典序最的上升序列Q显然其W一个元素A[i]必须满F[i]>=MQ注意，不是{于Q是大于{于Q）Q找到满个条件的最的i卛_。然后，讄前已l求Z该序列的Wx个元素ؓA[y]Q则W?x+1)个元素A[z]需要满的条g是A[z]>A[y]Q且F[z]=F[y]-1Q找到满个条件的最的z即ؓ该序列的W?x+1)个元素。按照这U方法，扫描一遍就可以求出整个序列Q时间复杂度为O(N)。如果整个序列的最长上升序列长?lt;MQ则无解?br />
代码Q?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 10010, MAXM = 1010, INF = ~0U >> 2;
int n, m, len, A[MAXN], F[MAXN], D[MAXN], res[MAXM];
void prepare()
{
D[len = 0] = INF; int l, r, mid;
rre(i, n) if (A[i] < D[len]) D[F[i] = ++len] = A[i]; else {
l = 0; r = len;
while (l < r) {
mid = l + r + 1 >> 1;
if (A[i] < D[mid]) l = mid; else r = mid - 1;
}
F[i] = l + 1; D[l + 1] = A[i];
}
}
void solve()
{
int x, y;
re(i, n) if (F[i] >= m) {
res[0] = A[i]; if (m == 1) return; x = m - 1; y = 1;
re2(j, i+1, n) if (F[j] >= x && A[j] > res[y - 1]) {res[y++] = A[j]; if (y == m) return; else x--;}
}
}
int main()
{
scanf("%d", &n); re(i, n) scanf("%d", &A[i]);
prepare();
int m_s; scanf("%d", &m_s);
re(i, m_s) {scanf("%d", &m); if (m > len) puts("Impossible"); else {solve(); re(j, m-1) printf("%d ", res[j]); printf("%d\n", res[m - 1]);}}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 10010, MAXM = 1010, INF = ~0U >> 2;
int n, m, len, A[MAXN], F[MAXN], D[MAXN], res[MAXM];
void prepare()
{
D[len = 0] = INF; int l, r, mid;
rre(i, n) if (A[i] < D[len]) D[F[i] = ++len] = A[i]; else {
l = 0; r = len;
while (l < r) {
mid = l + r + 1 >> 1;
if (A[i] < D[mid]) l = mid; else r = mid - 1;
}
F[i] = l + 1; D[l + 1] = A[i];
}
}
void solve()
{
int x, y;
re(i, n) if (F[i] >= m) {
res[0] = A[i]; if (m == 1) return; x = m - 1; y = 1;
re2(j, i+1, n) if (F[j] >= x && A[j] > res[y - 1]) {res[y++] = A[j]; if (y == m) return; else x--;}
}
}
int main()
{
scanf("%d", &n); re(i, n) scanf("%d", &A[i]);
prepare();
int m_s; scanf("%d", &m_s);
re(i, m_s) {scanf("%d", &m); if (m > len) puts("Impossible"); else {solve(); re(j, m-1) printf("%d ", res[j]); printf("%d\n", res[m - 1]);}}
return 0;
}
??a title="[HAOI2006]数字序列 " >[HAOI2006]数字序列
首先Q由于序列的所有元素都是整敎ͼ所以可以将原序列的所有元素减d的下标，q样把上升序列转化Z下降序列了?br />W一问的l果昄是(N-新序列的最长不下降序列长度)。关键在于第二问。以下A均表C新序列?br />设F[i]ZA[i]l尾的最长不下降序列长度Q同P求法不用说了Q，G[i]为在A[i]不修改的前提下将A[0..i]转变Z下降序列的最修攚w。首先求出F[i]Q然后在求G[i]Ӟ枚D上一?#8220;不动?#8221;Q就是不修改的元素）A[j]Q显然必LA[j]<=A[i]且F[j]=F[i]-1Q，q样最修攚w是G[j]+(A[j..i]转变Z下降序列的最修攚wQ。可以证明，A[j..i]的最优修Ҏ案必然是A[j+1..t]全部修改为A[j]QA[t+1..i]全部修改为A[i]Q这里t是一个[j..i]范围的倹{问题就是如何求出最优的tQ?br />一开始，假设t=jQ即把A[j+1..i-1]全部修改为A[i]Q计出修改量，设ؓS。然后，׃A[j+1..i-1]之间的元素要么小于A[j]Q要么大于A[i]Q这个是昄的囧Q，我们把小于A[j]的元素称?#8220;数”Q把大于A[i]的元素称?#8220;大数”Q则当t取t0Ӟ修改量ؓS-(A[i]-A[j])*(A[j+1..t0]中的“数”个数减去“大数”个数Q。这P只需扫描一下，求出使得(A[j+1..t0]中的“数”个数减去“大数”个数Q值最大的t0卛_?br />当然q有一个问题，对于同一个iQ满?#8220;A[j]<=A[i]且F[j]=F[i]-1”的元素个数可能有很多Q如果一个一个枚举，一个一个扫描，会很慢的?#8230;…解决Ҏ是，求出满q个条g的j中最的一个，设ؓj0Q然后把A[j0+1..i-1]中的所?#8220;数”?#8220;大数”全部处理出来Q然后用cM前缀和的Ҏp搞了?#8230;…当然Qؓ了找到j0Q需要徏一个二分图Q边?F[i], i)?br />最后，Z方便Q可以把A序列的左边加一?INFQ右边加一?INF。最后ȝ旉复杂度，理论上ؓO(N2)Q但׃是随机数据，所以远q达不到q个U别?br />
代码Q?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 40010, INF = ~0U >> 2;
struct edge {
int a, b, pre, next;
} E[MAXN << 1];
int n, m, A[MAXN], D[MAXN], F[MAXN], W[MAXN], res1;
ll G[MAXN], res2;
void init_d()
{
re(i, n) E[i].pre = E[i].next = i; m = n;
}
void add_edge(int a, int b)
{
E[m].a = a; E[m].b = b; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
void init()
{
scanf("%d", &n);
A[0] = -INF; re1(i, n) {scanf("%d", &A[i]); A[i] -= i;} A[++n] = INF; n++;
}
void solve()
{
init_d(); F[0] = 0; G[0] = 0; D[0] = -INF; add_edge(0, 0); int len = 0, l, r, mid, x, maxw; ll sum, tmp;
re2(i, 1, n) {
if (A[i] >= D[len]) D[F[i] = ++len] = A[i]; else {
l = 0; r = len;
while (l < r) {
mid = l + r + 1 >> 1;
if (A[i] >= D[mid]) l = mid; else r = mid - 1;
}
D[F[i] = ++l] = A[i];
}
for (int p=E[F[i]-1].next; ; p=E[p].next) if (A[i] >= A[x = E[p].b]) break;
W[x] = 0; re2(j, x+1, i) if (A[j] < A[i]) W[j] = W[j - 1] + 1; else W[j] = W[j - 1] - 1;
sum = 0; maxw = -INF; G[i] = ~0Ull >> 2;
rre2(j, i, x) {
if (A[j] <= A[i] && F[j] == F[i] - 1) {
tmp = G[j] + sum; if (tmp < G[i]) G[i] = tmp;
tmp = G[j] + sum - (ll) (maxw - W[j]) * (A[i] - A[j]); if (tmp < G[i]) G[i] = tmp;
}
if (A[j] > A[i]) sum += A[j] - A[i]; else sum += A[i] - A[j];
if (W[j] > maxw) maxw = W[j];
}
add_edge(F[i], i);
}
res1 = n - F[n - 1] - 1; res2 = G[n - 1];
}
void pri()
{
cout << res1 << endl << res2 << endl;
}
int main()
{
init();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 40010, INF = ~0U >> 2;
struct edge {
int a, b, pre, next;
} E[MAXN << 1];
int n, m, A[MAXN], D[MAXN], F[MAXN], W[MAXN], res1;
ll G[MAXN], res2;
void init_d()
{
re(i, n) E[i].pre = E[i].next = i; m = n;
}
void add_edge(int a, int b)
{
E[m].a = a; E[m].b = b; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
void init()
{
scanf("%d", &n);
A[0] = -INF; re1(i, n) {scanf("%d", &A[i]); A[i] -= i;} A[++n] = INF; n++;
}
void solve()
{
init_d(); F[0] = 0; G[0] = 0; D[0] = -INF; add_edge(0, 0); int len = 0, l, r, mid, x, maxw; ll sum, tmp;
re2(i, 1, n) {
if (A[i] >= D[len]) D[F[i] = ++len] = A[i]; else {
l = 0; r = len;
while (l < r) {
mid = l + r + 1 >> 1;
if (A[i] >= D[mid]) l = mid; else r = mid - 1;
}
D[F[i] = ++l] = A[i];
}
for (int p=E[F[i]-1].next; ; p=E[p].next) if (A[i] >= A[x = E[p].b]) break;
W[x] = 0; re2(j, x+1, i) if (A[j] < A[i]) W[j] = W[j - 1] + 1; else W[j] = W[j - 1] - 1;
sum = 0; maxw = -INF; G[i] = ~0Ull >> 2;
rre2(j, i, x) {
if (A[j] <= A[i] && F[j] == F[i] - 1) {
tmp = G[j] + sum; if (tmp < G[i]) G[i] = tmp;
tmp = G[j] + sum - (ll) (maxw - W[j]) * (A[i] - A[j]); if (tmp < G[i]) G[i] = tmp;
}
if (A[j] > A[i]) sum += A[j] - A[i]; else sum += A[i] - A[j];
if (W[j] > maxw) maxw = W[j];
}
add_edge(F[i], i);
}
res1 = n - F[n - 1] - 1; res2 = G[n - 1];
}
void pri()
{
cout << res1 << endl << res2 << endl;
}
int main()
{
init();
solve();
pri();
return 0;
}
]]>
本沙茶的W一个无向环套树模型Q纪念一?#8230;…
环套树，指的是每个连通块中点数都{于Ҏ的无向图Q称为无向环套树Q或者是每个Ҏ且只有一个前（UCؓ内向环套树）或后l（UCؓ外向环套树）的有向图Q由于这个图的每个连通块当中有且只有一个环Q注意，可能是自环，即长度ؓ1的环Q，且这个环上的每个炚w可以当作根引Z|Q所以叫“环套?#8221;?br />
对于无向环套树，先将整个图进行一ơDFSQ当中如果发现有逆向边（q条边第一ơ被发现必然是作为逆向边的Q也是L是终点的后代Q，p明找Cq个环，记录其v点和l点Q注意，如果有多个连通块的话Q不能退出，要l遍历完Q，再不断上溯（因此在DFSq程中当然要记录父边了囧Q，可以找到整个环了，然后再以环上的结点ؓ根徏树即可，q样依次处理每个q通块?br />
对于内向环套树（外向cMQ，扄更ؓ单，只需要Q选一个点Q不断去扑֮的前，同时记录扑ֈ的点序列Q直到某个点在序列中出现两次为止Q此时这个点以及序列中它两次出现的位|中间的所有点Q就是环上的点，序也顺便记录下来，然后树也不用ZQ直接在原图中找p了?br />
对于q题Q由于每个点都有且只有一个后l，所以是外向环套树，不过本沙茶更們于它的基图（无向图，是无向环套树Q，然后是一个DP了囧……
代码Q?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 1000010;
const ll INF = ~0Ull >> 2;
struct edge {
int a, b, pre, next;
} E0[MAXN * 3], E[MAXN << 1];
int n, m0, m, A[MAXN], stk[MAXN], st[MAXN], pr[MAXN], Q[MAXN];
ll F[MAXN][2], res = 0;
bool vst[MAXN], vst0[MAXN];
void init_d()
{
re(i, n) E0[i].pre = E0[i].next = E[i].pre = E[i].next = i; if (n & 1) m0 = n + 1; else m0 = n; m = n;
}
void add_edge0(int a, int b)
{
E0[m0].a = a; E0[m0].b = b; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
E0[m0].a = b; E0[m0].b = a; E0[m0].pre = E0[b].pre; E0[m0].next = b; E0[b].pre = m0; E0[E0[m0].pre].next = m0++;
}
void add_edge(int a, int b)
{
E[m].a = a; E[m].b = b; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
void init()
{
scanf("%d", &n); int x; init_d();
re(i, n) {
scanf("%d%d", &A[i], &x); add_edge0(--x, i);
}
}
void sol0(int x)
{
Q[0] = x; int i, j, front, rear;
for (front=0, rear=0; front<=rear; front++) {
i = Q[front];
for (int p=E0[i].next; p != i; p=E0[p].next) {
j = E0[p].b;
if (!vst0[j]) {Q[++rear] = j; vst0[j] = 1; add_edge(i, j);}
}
}
rre3(z, rear, 0) {
i = Q[z];
F[i][0] = 0; F[i][1] = A[i];
for (int p=E[i].next; p != i; p=E[p].next) {
j = E[p].b; F[i][0] += F[j][0] >= F[j][1] ? F[j][0] : F[j][1]; F[i][1] += F[j][0];
}
}
}
void solve()
{
re(i, n) {vst[i] = vst0[i] = 0; st[i] = E0[i].next;} int x, y, tp, x0, y0; bool FF, FF2; ll tmp0, tmp1, tmp00, tmp01, res0;
re(i, n) if (!vst[i]) {
stk[tp = 0] = i; vst[i] = 1; FF2 = 0;
while (tp >= 0) {
x = stk[tp]; FF = 0;
for (int p=st[x]; p != x; p=E0[p].next) {
y = E0[p].b;
if (!vst[y]) {vst[y] = 1; stk[++tp] = y; pr[y] = p; st[x] = E0[p].next; FF = 1; break;}
else if (p != (pr[x] ^ 1) && !FF2) {FF2 = 1; x0 = x; y0 = y;}
}
if (!FF) tp--;
}
if (FF2) {
tp = 0; vst0[y0] = 1; while (x0 != y0) {stk[tp++] = x0; vst0[x0] = 1; x0 = E0[pr[x0]].a;} stk[tp++] = y0;
re(j, tp) sol0(stk[j]);
tmp0 = F[stk[0]][0]; tmp1 = -INF;
re2(j, 1, tp) {
tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
tmp01 = tmp0 + F[stk[j]][1];
tmp0 = tmp00; tmp1 = tmp01;
}
res0 = tmp0 >= tmp1 ? tmp0 : tmp1;
tmp0 = -INF; tmp1 = F[stk[0]][1];
re2(j, 1, tp) {
tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
tmp01 = tmp0 + F[stk[j]][1];
tmp0 = tmp00; tmp1 = tmp01;
}
res += res0 >= tmp0 ? res0 : tmp0;
}
}
}
void pri()
{
cout << res << endl;
}
int main()
{
init();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 1000010;
const ll INF = ~0Ull >> 2;
struct edge {
int a, b, pre, next;
} E0[MAXN * 3], E[MAXN << 1];
int n, m0, m, A[MAXN], stk[MAXN], st[MAXN], pr[MAXN], Q[MAXN];
ll F[MAXN][2], res = 0;
bool vst[MAXN], vst0[MAXN];
void init_d()
{
re(i, n) E0[i].pre = E0[i].next = E[i].pre = E[i].next = i; if (n & 1) m0 = n + 1; else m0 = n; m = n;
}
void add_edge0(int a, int b)
{
E0[m0].a = a; E0[m0].b = b; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
E0[m0].a = b; E0[m0].b = a; E0[m0].pre = E0[b].pre; E0[m0].next = b; E0[b].pre = m0; E0[E0[m0].pre].next = m0++;
}
void add_edge(int a, int b)
{
E[m].a = a; E[m].b = b; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
void init()
{
scanf("%d", &n); int x; init_d();
re(i, n) {
scanf("%d%d", &A[i], &x); add_edge0(--x, i);
}
}
void sol0(int x)
{
Q[0] = x; int i, j, front, rear;
for (front=0, rear=0; front<=rear; front++) {
i = Q[front];
for (int p=E0[i].next; p != i; p=E0[p].next) {
j = E0[p].b;
if (!vst0[j]) {Q[++rear] = j; vst0[j] = 1; add_edge(i, j);}
}
}
rre3(z, rear, 0) {
i = Q[z];
F[i][0] = 0; F[i][1] = A[i];
for (int p=E[i].next; p != i; p=E[p].next) {
j = E[p].b; F[i][0] += F[j][0] >= F[j][1] ? F[j][0] : F[j][1]; F[i][1] += F[j][0];
}
}
}
void solve()
{
re(i, n) {vst[i] = vst0[i] = 0; st[i] = E0[i].next;} int x, y, tp, x0, y0; bool FF, FF2; ll tmp0, tmp1, tmp00, tmp01, res0;
re(i, n) if (!vst[i]) {
stk[tp = 0] = i; vst[i] = 1; FF2 = 0;
while (tp >= 0) {
x = stk[tp]; FF = 0;
for (int p=st[x]; p != x; p=E0[p].next) {
y = E0[p].b;
if (!vst[y]) {vst[y] = 1; stk[++tp] = y; pr[y] = p; st[x] = E0[p].next; FF = 1; break;}
else if (p != (pr[x] ^ 1) && !FF2) {FF2 = 1; x0 = x; y0 = y;}
}
if (!FF) tp--;
}
if (FF2) {
tp = 0; vst0[y0] = 1; while (x0 != y0) {stk[tp++] = x0; vst0[x0] = 1; x0 = E0[pr[x0]].a;} stk[tp++] = y0;
re(j, tp) sol0(stk[j]);
tmp0 = F[stk[0]][0]; tmp1 = -INF;
re2(j, 1, tp) {
tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
tmp01 = tmp0 + F[stk[j]][1];
tmp0 = tmp00; tmp1 = tmp01;
}
res0 = tmp0 >= tmp1 ? tmp0 : tmp1;
tmp0 = -INF; tmp1 = F[stk[0]][1];
re2(j, 1, tp) {
tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
tmp01 = tmp0 + F[stk[j]][1];
tmp0 = tmp00; tmp1 = tmp01;
}
res += res0 >= tmp0 ? res0 : tmp0;
}
}
}
void pri()
{
cout << res << endl;
}
int main()
{
init();
solve();
pri();
return 0;
}
]]>
]]>
说实话我W一ơ尝试写炮兵阵地是在2009q?#8230;…已经q去两年多了Q终于找C一个好的解?#8230;…庆祝一?#8230;…
【状态压~DP?br />所谓状态压~DPQ就是对于某些DP问题Q每一阶段的状态都有很多维Q要利用某些手段它们压~到一l_一个正整数Q，Zq行状态的_Q去掉不合法的状态）Q然后再q行DP。这里讲的主要是传统的状压DPQ有一U基?#8220;插头”的DPQ更高Q以后再搞?br />对于本题Q可以设计出一个这L状态：[0..1][0..1][0..1]...[0..1]Q有M个[0..1]Q，表示该行的每个格子放不放炮兵Q如果放Qؓ1Q否则ؓ0。显Ӟq是一个M位二q制敎ͼ如果能把它们压羃成一个int好了?br />
【如何压~?br />W一个问题是q么多维的状态如何压~的问题?br />对于本题Q由于是二进制数Q直接压~就可以了。但是对于某些情况，状态是个三q制敎ͼ每个格子的属性都?U）甚至更多q制敎ͼq样Q直接压~会D无法使用位运，从而“解压”变得很麻烦，耗时也很长（需要暴力）Q因此，可以每位三q制都拆成两位二q制Q?br />0->00
1->01
2->10
Q当?拆成10?拆成11也木有问题，只要能区分开p了）
q样Q每个状态就可以?个二q制数来表示Q可以在构造出所有合法状态以后将每个状态所对应的两位二q制数存到struct里面Q用时调出卛_?br />
【如何精?br />q个问题是最重要的，因ؓQ如果不_Q在枚D状态以及{Uȝ时候就会枚丑ֈ很多不合法状态，D旉费?br />所谓精Q是指在预处理以及DPq程中，量避开不合法状态?br />Q?Q预处理中的_Q?br />包括3个部分：
<1>扑ֈ所有可能的合法状态ƈ~号Q根据题意限Ӟ有的状态在阶段内就不合法（比如本题Q一行一阶段Q那么凡是有两个1位的距离于2的状态都不合法）Q而且q种状态所占的比重往往q很大（本题中，M=10Ӟ也只?0U可能的合法状态）Q此ӞZ扑ֈq些合法状态，可以DFS构造实现?br />需要注意的是，有的题不光要扑ֈ一个阶D内的合法状态，q要扑ֈ两个或两个以上阶D内的合法状态（比如那个有关多米诺骨牌的题）Q此旉要两个int同时DFSQ?br />在找到合法状态以后，需要对每个合法状态进行编P以达?#8220;压羃”的目的。这里就涉及C状态编号和状态表C的问题Q比如，状?001Q表CZؓ9Q在DFS中第一个被搜到Q因此编号ؓ0Q不要搞混了q两个（其不要搞“~号?”?#8220;状态表CZؓ0”Q它们是不同的）。在预处理和DP的过E中Q所有涉及到状态的数组下标Q全部是~号而不是表C，知道~号要求表示Q可以在DFS中记录的数组里面调，而知道表C求编P可以利用逆数l或者哈希；
<2>扑ֈ每一阶段的合法状态：即?lt;1>中被判定为合法的状态，在具体的各个阶段中也未必合法Q比如本题，如果某一行的某一个位|是'H'Q不能放Q而某一个状态在q里放了Q则不合法）Q因此要Ҏ个阶D再枚D一遍，扑ֈ真正合法的状态，q计入一个vectorQ?br /><3>扑ֈ状态{UM的合法状态：在状态{UMQ往往要求状态不冲突Q比如本题，在连l的三个阶段中，都不能有某一位有两个?的情况）Q因此，q要枚D每个状态在转移时与其不冲突的状态，q计入vector?br />注意Q有时候这一步不是很Ҏq行Q需要在DPq程中进行；
Q?QDPq程中的_Q?br />DPq程中，枚D状态、{Ud{都只枚丑法的Q在vector里面调（注意vector里记录的全都是状态编可不是表C！Q，可以大大减少枚D量，不过有时候，q会有一些时间浪费，q时候，可以采取一些其它的办法来精Q比如再ơ进行DFS构造合法状态等?br />
MQ这c问题的目标是“_Q精Q再_Q枚D到的不合法状态减到最?#8221;?br />代码Q?br />
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define pb push_back
#define IR iterator
typedef vector <int> vi;
const int MAXN = 103, MAXM = 11, MAXS = 100, INF = ~0U >> 2;
int n, m, S, A[MAXN], B[MAXS], T1[MAXS], F[MAXN][MAXS][MAXS], res;
bool F0[MAXN][MAXS];
vi P0[MAXN], P1[MAXS][MAXS];
void init()
{
scanf("%d%d", &n, &m); getchar();
re1(i, n) {A[i] = 0; re(j, m) A[i] |= ((getchar() == 'P') << j); getchar();}
}
void dfs(int v, int ST)
{
if (v >= m) B[S++] = ST; else {dfs(v + 3, ST | (1 << v)); dfs(v + 1, ST);}
}
void prepare()
{
S = 0; dfs(0, 0);
re(i, S) {T1[i] = 0; for (int j=B[i]; j; j-=j&(-j)) T1[i]++;}
re1(i, n) re(j, S) if (!(~A[i] & B[j])) {P0[i].pb(j); F0[i][j] = 1;} P0[0].pb(S - 1); F0[0][S - 1] = 1;
re(i, S) re(j, S) if (!(B[i] & B[j])) re(k, S) if (!(B[i] & B[k]) && !(B[j] & B[k])) P1[i][j].pb(k);
}
void solve()
{
re3(i, 0, n) re(j1, S) re(j2, S) F[i][j1][j2] = -INF; F[0][S - 1][S - 1] = 0;
vi::IR vi_e0, vi_e1, vi_e2; int j0, j1, k, V;
re(i, n) {
vi_e0 = P0[i].end(); if (i) vi_e1 = P0[i - 1].end(); else vi_e1 = P0[i].end();
for (vi::IR p=P0[i].begin(); p != vi_e0; p++)
for (vi::IR p_=P0[i ? i - 1 : i].begin(); p_ != vi_e1; p_++) {
j0 = *p; j1 = *p_;
if (!(B[j0] & B[j1])) {
vi_e2 = P1[j0][j1].end();
for (vi::IR p__ = P1[j0][j1].begin(); p__ != vi_e2; p__++) {
k = *p__;
if (F0[i + 1][k]) {
V = F[i][j0][j1] + T1[k];
if (V > F[i + 1][k][j0]) F[i + 1][k][j0] = V;
}
}
}
}
}
res = 0; re(i, S) re(j, S) if (F[n][i][j] > res) res = F[n][i][j];
}
void pri()
{
printf("%d\n", res);
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define pb push_back
#define IR iterator
typedef vector <int> vi;
const int MAXN = 103, MAXM = 11, MAXS = 100, INF = ~0U >> 2;
int n, m, S, A[MAXN], B[MAXS], T1[MAXS], F[MAXN][MAXS][MAXS], res;
bool F0[MAXN][MAXS];
vi P0[MAXN], P1[MAXS][MAXS];
void init()
{
scanf("%d%d", &n, &m); getchar();
re1(i, n) {A[i] = 0; re(j, m) A[i] |= ((getchar() == 'P') << j); getchar();}
}
void dfs(int v, int ST)
{
if (v >= m) B[S++] = ST; else {dfs(v + 3, ST | (1 << v)); dfs(v + 1, ST);}
}
void prepare()
{
S = 0; dfs(0, 0);
re(i, S) {T1[i] = 0; for (int j=B[i]; j; j-=j&(-j)) T1[i]++;}
re1(i, n) re(j, S) if (!(~A[i] & B[j])) {P0[i].pb(j); F0[i][j] = 1;} P0[0].pb(S - 1); F0[0][S - 1] = 1;
re(i, S) re(j, S) if (!(B[i] & B[j])) re(k, S) if (!(B[i] & B[k]) && !(B[j] & B[k])) P1[i][j].pb(k);
}
void solve()
{
re3(i, 0, n) re(j1, S) re(j2, S) F[i][j1][j2] = -INF; F[0][S - 1][S - 1] = 0;
vi::IR vi_e0, vi_e1, vi_e2; int j0, j1, k, V;
re(i, n) {
vi_e0 = P0[i].end(); if (i) vi_e1 = P0[i - 1].end(); else vi_e1 = P0[i].end();
for (vi::IR p=P0[i].begin(); p != vi_e0; p++)
for (vi::IR p_=P0[i ? i - 1 : i].begin(); p_ != vi_e1; p_++) {
j0 = *p; j1 = *p_;
if (!(B[j0] & B[j1])) {
vi_e2 = P1[j0][j1].end();
for (vi::IR p__ = P1[j0][j1].begin(); p__ != vi_e2; p__++) {
k = *p__;
if (F0[i + 1][k]) {
V = F[i][j0][j1] + T1[k];
if (V > F[i + 1][k][j0]) F[i + 1][k][j0] = V;
}
}
}
}
}
res = 0; re(i, S) re(j, S) if (F[n][i][j] > res) res = F[n][i][j];
}
void pri()
{
printf("%d\n", res);
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
]]>
q是一道线D|操作的极品题Q因为它?个操作刚好覆盖了U段树操作问题的3U处理思\Q可以说是把U段树操作的全部内容都包含进M?br />
U段树是一U静态的数据l构Q因Z늺D|一旦徏成，其Ş态就永远不会发生变化Q改变的仅仅是结点上记录的各U信息的倹{因此，对于U段树操作，核心问题也就是如何维护和处理q些信息。ȝ来说Q对于线D|l点信息的维护和处理Q有以下3U基本思\Q?br />Q?Q左叛_中型Q?br />所谓左叛_中，是用左叛_l点存储的信息来得到父结点存储的信息的|q是最常见的线D|l护Ҏ。D一些简单的例子Q比如结点的SUM域表Cl点区间上所有元素的和，那么q个域维护的Ҏ是“父结点SUM=左子l点SUM+叛_l点SUM”Q再比如l点的MAX/MIN域表Cl点区间上所有元素的最?|那么l护Ҏ是“父结点MAX/MIN=max/min{左子l点MAX/MIN,叛_l点MAX/MIN}”。这U维护方法也比较单，只要在每ơ对子结点进行修改之后upd一下就行了Q对于那些自向下递归Q而且涉及到改值的操作Q在递归完左叛_l点后一定要记得upd一下）Q在q之中有一个很重要的思想是“左右q箋D?#8221;思想Q如果题目中要求L一个区间内的具有某U性质的最长的q箋序列Q也是子区_Q比如最长连l上升子序列?1值问题中q箋?D|者非0D（在具体问题中是q箋的空闲段或者占用段Q等Q可以在每个l点上维护三个域QlS、rS和SQ分别表Cl点区间左端Q从区间的最左端开始的Q具有这U性质的最长连l序列的长度Q该l点区间右端Q到区间的最右端l束的）hq种性质的最长连l序列的长度和该区间内具有这U性质的最长连l序列的长度Q也是要求的那个东东）Q则l护Ҏ?#8220;父结点lS=左子l点lSQ左子结点lS<左子l点lenQ或左子l点len+叛_l点lSQ左子结点lS=左子l点lenQ，父结点rScMQ父l点S=max{左子l点S,叛_l点S,左子l点rS+叛_l点lS}”Q此外，׃要求的这个区间可能被拆成多个q箋的结点区_因此需要按序合ƈq些区间Q合q的Ҏ是：讄S0和S1QS0表示不保证能延下去的区间长度，S0=上一个区间的S1+本区间的lSQS1表示可以延下去的区间长度，S1=上一个区间的S1+本区间lenQ如果本区间整个都是满条g的，即S=lenQ或本区间的rSQ本区间不都是满x件的Q即S<lenQ，取过E中所有S0和区间S的最大值即为结果?br />在HDU2871中，应用左右归中的方法维护的信息是“最长连l空闲段”的长度，New操作需要；
Q?Q调整边界型Q?br />考虑q样一个问题：现在要插入、删除一些[0, 100000)的整敎ͼq且在此q程中不断询问第K的整数是多，怎么办？q树可以实玎ͼ但线D|昄是更好的Ҏ。对每个l点Q存储一个K0DCZ于该l点区间内的整数的个敎ͼ则查扄K的时候只需要不断执行以下操作：Kth(A, K)Q表C在l点A代表的区间内扄K的Q然后，若K<=l点A的左子结点K0|则执行Kth(A的左子结? K)Q否则执行Kth(A的右子结? K-A左子l点的K0)Q这和^衡树似Q，直到扑ֈ叶结点ؓ止。这U方法称?#8220;调整边界?#8221;Q即随着l点深入Q不断羃（自顶向下Q或扩大Q自底向上）范围Q最后找到结果。像扄K这L操作属于自顶向下型，而像“扑ֈX所在的h某种性质的最长的q箋区间”属于自底向上型Q注意和本题的Free不一PQ?br />
Q?Q标记辅助型Q?br />q种l护信息的方法，特点是利用标记来l护信息Q即对于某些l点Q主要是叶结点，因ؓ其标C再下放）Q直接用标记来得到一些数据，比如对于HDU2871q一题，其中对于叶结点位于的插入U段的标P使用的就是标记?br />
下面是本?个操作的具体实现Q?br /><1>U段树结点定义：
本题需要两늺D|Q这是因为New与Free操作对于tot域（插入U段左端点的M敎ͼ会造成不同的媄响，具体来说Q在New操作中，totg会被同时加上Q需要另外一个操作加上）Q然而在Free操作中，totg被同时清I，q样׃D在对某个l点清空Q该l点包含在某个Free操作要清I的U段中）q打?标记之后Q如果紧接着又插入一条包含这个结点区间的新线D，则这个结点的0标记׃丧失Q这样在紧接着下传的时候，其子l点的tot值就不会被清I（事实上已l被清空了）。所以，tot域彻底{Ud另一늺D|里?
struct node {
int len, mr, lsc, rsc, sc;
} T[MAXN << 2];
struct node0 {
int tot;
bool mr;
} T0[MAXN << 2];
其中lsc、rsc、sc是q箋I闲D늚长度Q用左右归中的方法维护）Qmr是一个整体赋值标讎ͼ在T中，mr的D?1表示无标讎ͼ未被整体赋|Q若?表示被整体清I，若大?表示整体被一条线D覆盖，mr值就是这条线D늚~号Qؓ区分不同U段Q这里按照输入顺序对每一条New操作插入的线D以1?……~号Q，在T0中，mr=1表示在Reset中被整体清空Qmr=0表示无标记?br /><2>操作处理Q?br />1)Reset操作Q将T、T0的根l点打上清空标记卛_Q?br />2)NewQ涉及到两个操作Q分别是找最左的长度为x的连l空闲段Q以及插入一条线Dc对于前者，可以Ҏlsc、rsc、sc的|按照“先左子结点，再跨两个子l点Q最后右子结?#8221;的顺序求得（详见代码Q；对于后者就不用说了Q太Ҏ实现了（注意标记的处理以及updQ另外要插入一个totQ；int len, mr, lsc, rsc, sc;
} T[MAXN << 2];
struct node0 {
int tot;
bool mr;
} T0[MAXN << 2];
3)FreeQ也涉及两个操作Q分别是找一个点x所在的U段Q插入过的线D）长度以及删除一条线D，对于前者可New插入q的所有线D늚左右端点预存hQ然后找C表区间[x, x]的结点的mr|也就是结点x被编号ؓ马的线D覆盖）Q再在预存的U段中找到即可。对于后者，直接清空卛_Q不要在T0中打标记Q而要单独删除一个totQ；
4)GetQ直接利用T0中的tot扑ֈWK的值即可；
代码
]]>
注意Q更改\径条数应该在出队时更改，而不能在入队时更改，因ؓ可能在该路径出队之前会有新的比它更短的\径入队?br>
代码QPKU2449Q：
#include <iostream>
#include <stdio.h>
#include <queue>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
const int MAXN = 1500, MAXM = 150000, INF = ~0U >> 2;
struct edge {
int kk, len, next;
} ed[MAXM], ed2[MAXM];
int n, m, s, t, k_, hd[MAXN], tl[MAXN], hd2[MAXN], tl2[MAXN], h[MAXN], q[MAXN + 1], No[MAXN], res = -1;
bool vst[MAXN];
struct qnode {
int i, g;
};
typedef priority_queue <qnode, vector<qnode> > pq;
pq z;
bool operator< (qnode q1, qnode q2)
{
return q1.g + h[q1.i] > q2.g + h[q2.i];
}
void init()
{
int a0, b0, l0;
scanf("%d%d", &n, &m);
re(i, n) hd[i] = tl[i] = hd2[i] = tl2[i] = -1;
re(i, m) {
scanf("%d%d%d", &a0, &b0, &l0); a0--; b0--;
ed[i].kk = b0; ed[i].len = l0; ed[i].next = -1;
if (hd[a0] == -1) hd[a0] = tl[a0] = i; else tl[a0] = ed[tl[a0]].next = i;
ed2[i].kk = a0; ed2[i].len = l0; ed2[i].next = -1;
if (hd2[b0] == -1) hd2[b0] = tl2[b0] = i; else tl2[b0] = ed2[tl2[b0]].next = i;
}
scanf("%d%d%d", &s, &t, &k_); --s; --t; k_ += s == t;
}
void prepare()
{
re(i, n) {h[i] = INF; vst[i] = 0;} h[t] = 0; vst[t] = 1; q[0] = t;
int i, h0, j, h1;
for (int front=0, rear=0; !(!front && rear == n || front == rear + 1); front == n ? front = 0 : front++) {
i = q[front]; h0 = h[i];
for (int p=hd2[i]; p != -1; p=ed2[p].next) {
j = ed2[p].kk; h1 = h0 + ed2[p].len;
if (h1 < h[j]) {
h[j] = h1;
if (!vst[j]) {vst[j] = 1; if (rear == n) q[rear = 0] = j; else q[++rear] = j;}
}
}
vst[i] = 0;
}
}
void solve()
{
qnode q0; q0.i = s; q0.g = 0; z.push(q0);
re(i, n) No[i] = 0;
int i, d0, j, d1;
while (!z.empty()) {
i = z.top().i; d0 = z.top().g; z.pop();
if (No[i] >= k_) continue;
No[i]++;
if (i == t && No[i] == k_) {res = d0; break;}
for (int p=hd[i]; p != -1; p=ed[p].next) {
j = ed[p].kk; d1 = d0 + ed[p].len;
q0.i = j; q0.g = d1; z.push(q0);
}
}
}
void pri()
{
printf("%d\n", res);
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <queue>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
const int MAXN = 1500, MAXM = 150000, INF = ~0U >> 2;
struct edge {
int kk, len, next;
} ed[MAXM], ed2[MAXM];
int n, m, s, t, k_, hd[MAXN], tl[MAXN], hd2[MAXN], tl2[MAXN], h[MAXN], q[MAXN + 1], No[MAXN], res = -1;
bool vst[MAXN];
struct qnode {
int i, g;
};
typedef priority_queue <qnode, vector<qnode> > pq;
pq z;
bool operator< (qnode q1, qnode q2)
{
return q1.g + h[q1.i] > q2.g + h[q2.i];
}
void init()
{
int a0, b0, l0;
scanf("%d%d", &n, &m);
re(i, n) hd[i] = tl[i] = hd2[i] = tl2[i] = -1;
re(i, m) {
scanf("%d%d%d", &a0, &b0, &l0); a0--; b0--;
ed[i].kk = b0; ed[i].len = l0; ed[i].next = -1;
if (hd[a0] == -1) hd[a0] = tl[a0] = i; else tl[a0] = ed[tl[a0]].next = i;
ed2[i].kk = a0; ed2[i].len = l0; ed2[i].next = -1;
if (hd2[b0] == -1) hd2[b0] = tl2[b0] = i; else tl2[b0] = ed2[tl2[b0]].next = i;
}
scanf("%d%d%d", &s, &t, &k_); --s; --t; k_ += s == t;
}
void prepare()
{
re(i, n) {h[i] = INF; vst[i] = 0;} h[t] = 0; vst[t] = 1; q[0] = t;
int i, h0, j, h1;
for (int front=0, rear=0; !(!front && rear == n || front == rear + 1); front == n ? front = 0 : front++) {
i = q[front]; h0 = h[i];
for (int p=hd2[i]; p != -1; p=ed2[p].next) {
j = ed2[p].kk; h1 = h0 + ed2[p].len;
if (h1 < h[j]) {
h[j] = h1;
if (!vst[j]) {vst[j] = 1; if (rear == n) q[rear = 0] = j; else q[++rear] = j;}
}
}
vst[i] = 0;
}
}
void solve()
{
qnode q0; q0.i = s; q0.g = 0; z.push(q0);
re(i, n) No[i] = 0;
int i, d0, j, d1;
while (!z.empty()) {
i = z.top().i; d0 = z.top().g; z.pop();
if (No[i] >= k_) continue;
No[i]++;
if (i == t && No[i] == k_) {res = d0; break;}
for (int p=hd[i]; p != -1; p=ed[p].next) {
j = ed[p].kk; d1 = d0 + ed[p].len;
q0.i = j; q0.g = d1; z.push(q0);
}
}
}
void pri()
{
printf("%d\n", res);
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
]]>
【离URMQ问题?br>题意Q对于一个序列A[1..N]Q共有Mơ提问，每次都是问A[l..r]Q?<=l<=r<=N)中的最|求出每次提问的答案?br>
Q?Q纯暴力枚DQO(NM)Q?br>Q?Q树状数l：O(M(logN)^2)【见树状数组解决ȝRMQ问题?br>Q?QST法QO(MlogN)……
ST法是基于分块DP的?br>设F[i][j]为A[i..(i+2^j-1)]Q共2^j个元素）中的最|前提是不能越界，即i+2^j-1 <= NQ，昄F可以通过DP的方式得刎ͼ
F[i][j] = min||max{F[i][j-1], F[i+2^(j-1)][j-1]}
边界QF[i][0]=A[i]?br>DP求F的值的旉复杂度ؓO(NlogN)Q一共只有NlogN个F值有意义Q；
然后Q对于求A[l..r]中的最|只要A[l..r]拆成若干q箋的段Q得每D늚长度都是2的整数次q就行了Q比如A[3..28]可以拆成A[3..18]、A[19..26]、A[27..28]三段Q长度分别是16Q?^4Q?Q?^3Q?Q?^1Q，所以min||max{A[3..28]} = min||max{F[3][4], F[19][3], F[27][1]}?br>关键是怎么拆？ҎQ求?r-l+1)Q即A[l..r]的长度）的二q制形式Q然后从高位C位依ơ遍历，如果扑ֈ1位就加上目前的位对应的幂Q如(28-3+1)=(11010)2Q所以依ơ找到F[3][4]、F[3+2^4][3]、F[3+2^4+2^3][1]。注意此旉要预先设一个数lBQB[2^i]=iQ以方便扑ֈ某个取出的幂对应的指数?br>昄Q最多只有logND，所以一ơ提问的旉复杂度ؓO(logN)?br>
其实q有一U方法，是先求出log(r-l+1)的|下取_Q设为xQ然后F[l][x]和F[r-2^x+1][x]中的较大/较小值就是A[l..r]中的最倹{这P一ơ提问的旉复杂度就降到了O(1)。问题是Q系llog函数灰常慢，也许一ơlog函数值的旉已经过了logNQ这h然得不偿失。所以仍然推荐上面的Ҏ?br>
【核心代码（以求最gؓ例，最大值类|?br>分段法：
int MIN(int l0, int r0)
{
int min = INF, h = l0, d0, b0;
for (int d = r0 - l0 + 1; d; d -= d0) {
d0 = d & -d; b0 = B[d0];
if (F[h][b0] < min) min = F[h][b0];
h += d0;
}
return min;
}
求log值法Q?br>
{
int min = INF, h = l0, d0, b0;
for (int d = r0 - l0 + 1; d; d -= d0) {
d0 = d & -d; b0 = B[d0];
if (F[h][b0] < min) min = F[h][b0];
h += d0;
}
return min;
}
int MIN(int l0, int r0)
{
int v = (int)floor(log2(r0 - l0 + 1.0)), s1 = F[l0][v], s2 = F[r0 - (1 << v) + 1][v];
return s1 <= s2 ? s1 : s2;
}
求F数组值的预处理代码（注意Q如果采用求log值的Ҏ׃需要B数组了）Q?br>
{
int v = (int)floor(log2(r0 - l0 + 1.0)), s1 = F[l0][v], s2 = F[r0 - (1 << v) + 1][v];
return s1 <= s2 ? s1 : s2;
}
void prepare()
{
re(i, n) F[i][0] = a[i];
int x;
re2(j, 1, MAXS) {
if ((1 << j) <= n) B[1 << j] = j;
x = n - (1 << j) + 1;
re(i, x) F[i][j] = min(F[i][j - 1], F[i + (1 << j - 1)][j - 1]);
}
}
{
re(i, n) F[i][0] = a[i];
int x;
re2(j, 1, MAXS) {
if ((1 << j) <= n) B[1 << j] = j;
x = n - (1 << j) + 1;
re(i, x) F[i][j] = min(F[i][j - 1], F[i + (1 << j - 1)][j - 1]);
}
}
【后l效率测试，发现当N=M=100000的随机数据中Q两U方法都可以?.4s以内得出正确l果Q其中log值法比分D|略慢0.01s左右Q相差不大，但考虑?#8220;量用数学函?#8221;的原则，仍推荐分D|?br>
]]>