16.7.13

贪心（转载）
转

动态规划（转载）

动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度，因此它比回溯法、暴力法等要快许多。
首先，我们要找到某个状态的最优解，然后在它的帮助下，找到下一个状态的最优解。

状态 - 要求解的问题。
状态转移方程 - 描述状态之间是如何转移的（如何由子问题得到）。

eg：一个数的序列bi，当b1 < b2 < … < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, …, aN)，我们可以得到一些上升的子序列(ai1, ai2, …, aiK)，这里1 <= i1 < i2 < … < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8)。 先对于给定的序列，求出最长上升子序列的长度。(LIS：longest increasing subsequence)

状态转移方程：d(i) = max{1, d(j)+1},其中j<i,A[j]<=A[i]

想要求d(i)，就把i前面的各个子序列中，最后一个数不大于A[i]的序列长度加1，然后取出最大的长度即为d(i)。当然了，有可能i前面的各个子序列中最后一个数都大于A[i]，那么d(i)=1，即它自身成为一个长度为1的子序列。

int lis(int A[], int n)
{
    int *d = new int[n];
    int len = 1;
    for(int i = 0; i < n; i++)
    {
        d[i] = 1;
        for(int j = 0; j < i ; ++j)
            if(A[j] <= A[i] && d[j]+1>d[i])
                d[i] = d[j] + 1;
            if(d[i] > len)
                len = d[i]; 
    } 
    delete []d;
    return len;
}

//转载外链中还有进阶讲解_(:зゝ∠)

//———————————–
线段树（转载）

线段树是一种二叉搜索树，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
线段树需要的空间为数组大小的四倍。

(1)：线段树的构造 void build(int node, int begin, int end);
主要思想是递归构造，如果当前节点记录的区间只有一个值，则直接赋值，否则递归构造左右子树，最后回溯的时候给当前节点赋值
（如下一个取区间最小数的线段树）

void build(int node, int begin, int end)    
{    
    if (begin == end)    
        segTree[node] = array[begin]; /* 只有一个元素,节点记录该单元素 */  
    else    
    {     
        /* 递归构造左右子树 */   
        build(2*node, begin, (begin+end)/2);    
        build(2*node+1, (begin+end)/2+1, end);   

        /* 回溯时得到当前node节点的线段信息 */    
        if (segTree[2 * node] <= segTree[2 * node + 1])    
            segTree[node] = segTree[2 * node];    
        else    
            segTree[node] = segTree[2 * node + 1];    
    }    
} 

若有如下调用：

    array[0] = 1, array[1] = 2,array[2] = 2, array[3] = 4, array[4] = 1, array[5] = 3;  
    build(1, 0, 5);

生成的线段树如图：

(2)：区间查询int query(int node, int begin, int end, int left, int right);
（其中node为当前查询节点，begin,end为当前节点存储的区间，left,right为此次query所要查询的区间）
主要思想是把所要查询的区间[a,b]划分为线段树上的节点，然后将这些节点代表的区间合并起来得到所需信息

int query(int node, int begin, int end, int left, int right)    
{   
    int p1, p2;    

    /*  查询区间和要求的区间没有交集  */  
    if (left > end || right < begin)    
        return -1;    

    /*  要求的区间包含当前查询区间 返回此段数值  */    
    if (begin >= left && end <= right)    
        return segTree[node];    

    /*  若不满足 继续搜线段树  */   
    p1 = query(2 * node, begin, (begin + end) / 2, left, right);   
    p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);    

    /*  返回所求值  */   
    if (p1 == -1)    
        return p2;    
    if (p2 == -1)    
        return p1;    
    if (p1 <= p2)    
        return  p1;    
    return  p2;      
}

可见，这样的过程一定选出了尽量少的区间，它们相连后正好涵盖了整个[left,right]，没有重复也没有遗漏。同时，考虑到线段树上每层的节点最多会被选取2个，一共选取的节点数也是O(log n)的，因此查询的时间复杂度也是O(log n)。

线段树并不适合所有区间查询情况，它的使用条件是“相邻的区间的信息可以被合并成两个区间的并区间的信息”。即问题是可以被分解解决的。

(3)：区间或节点的更新 及 线段树的动态维护void Updata(int node, int begin, int end, int ind, int add);

• a:单节点更新

void Updata(int node, int begin, int end, int ind, int add)/*单节点更新*/    
{    

    if( begin == end )    
    {    
        segTree[node] += add;    
        return ;    
    }    
    int m = ( left + right ) >> 1;    
    if(ind <= m)    
        Updata(node * 2,left, m, ind, add);    
    else    
        Updata(node * 2 + 1, m + 1, right, ind, add);    
    /*回溯更新父节点*/    
    segTree[node] = min(segTree[node * 2], segTree[node * 2 + 1]);     

} 

• b：区间更新（线段树中最有用的）

  需要用到延迟标记，每个结点新增加一个标记，记录这个结点是否被进行了某种修改操作(这种修改操作会影响其子结点)。对于任意区间的修改，我们先按照查询的方式将其划分成线段树中的结点，然后修改这些结点的信息，并给这些结点标上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个结点p，并且决定考虑其子结点，那么我们就要看看结点p有没有标记，如果有，就要按照标记修改其子结点的信息，并且给子结点都标上相同的标记，同时消掉p的标记。（优点在于，不用将区间内的所有值都暴力更新，大大提高效率，因此区间更新是最优用的操作）

void Change(node *p, int a, int b) /* 当前考察结点为p，修改区间为(a,b]*/  

{  

  if (a <= p->Left && p->Right <= b)  

  /* 如果当前结点的区间包含在修改区间内*/  

  {  

     ...... /* 修改当前结点的信息，并标上标记*/  

     return;  

  }  

  Push_Down(p); /* 把当前结点的标记向下传递*/  

  int mid = (p->Left + p->Right) / 2; /* 计算左右子结点的分隔点 

  if (a < mid) Change(p->Lch, a, b); /* 和左孩子有交集，考察左子结点*/  

  if (b > mid) Change(p->Rch, a, b); /* 和右孩子有交集，考察右子结点*/  

  Update(p); /* 维护当前结点的信息（因为其子结点的信息可能有更改）*/  

}

//———————–
主要应用及模板

(1)：区间最值查询问题 （见模板1）

(2)：连续区间修改或者单节点更新的动态查询问题 （见模板2）

//–模板1：
RMQ，查询区间最值下标—min

    #include<iostream>    

    using namespace std;    

    #define MAXN 100    
    #define MAXIND 256 //线段树节点个数    

    //构建线段树,目的:得到M数组.    
    void build(int node, int b, int e, int M[], int A[])    
    {    
        if (b == e)    
            M[node] = b; //只有一个元素,只有一个下标    
        else    
        {     
            build(2 * node, b, (b + e) / 2, M, A);    
            build(2 * node + 1, (b + e) / 2 + 1, e, M, A);    

            if (A[M[2 * node]] <= A[M[2 * node + 1]])    
                M[node] = M[2 * node];    
            else    
                M[node] = M[2 * node + 1];    
        }    
    }    

    //找出区间 [i, j] 上的最小值的索引    
    int query(int node, int b, int e, int M[], int A[], int i, int j)    
    {    
        int p1, p2;    

        //查询区间和要求的区间没有交集    
        if (i > e || j < b)    
            return -1;    

        if (b >= i && e <= j)    
            return M[node];    

        p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);    
        p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j);    

        //return the position where the overall    
        //minimum is    
        if (p1 == -1)    
            return M[node] = p2;    
        if (p2 == -1)    
            return M[node] = p1;    
        if (A[p1] <= A[p2])    
            return M[node] = p1;    
        return M[node] = p2;    

    }    


    int main()    
    {    
        int M[MAXIND]; //下标1起才有意义,否则不是二叉树,保存下标编号节点对应区间最小值的下标.    
        memset(M,-1,sizeof(M));    
        int a[]={3,4,5,7,2,1,0,3,4,5};    
        build(1, 0, sizeof(a)/sizeof(a[0])-1, M, a);    
        cout<<query(1, 0, sizeof(a)/sizeof(a[0])-1, M, a, 0, 5)<<endl;    
        return 0;    
    }    

//–模板2：
连续区间修改或者单节点更新的动态查询问题 （此模板查询区间和）

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

    #define lson l , m , rt << 1    
    #define rson m + 1 , r , rt << 1 | 1   
    #define root 1 , N , 1   
    #define LL long long    
    const int maxn = 111111;    
    LL add[maxn<<2];    
    LL sum[maxn<<2];    
    void PushUp(int rt) {    
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];    
    }    
    void PushDown(int rt,int m) {    
        if (add[rt]) {    
            add[rt<<1] += add[rt];    
            add[rt<<1|1] += add[rt];    
            sum[rt<<1] += add[rt] * (m - (m >> 1));    
            sum[rt<<1|1] += add[rt] * (m >> 1);    
            add[rt] = 0;    
        }    
    }    
    void build(int l,int r,int rt) {    
        add[rt] = 0;    
        if (l == r) {    
            scanf("%lld",&sum[rt]);    
            return ;    
        }    
        int m = (l + r) >> 1;    
        build(lson);    
        build(rson);    
        PushUp(rt);    
    }    
    void update(int L,int R,int c,int l,int r,int rt) {    
        if (L <= l && r <= R) {    
            add[rt] += c;    
            sum[rt] += (LL)c * (r - l + 1);    
            return ;    
        }    
        PushDown(rt , r - l + 1);    
        int m = (l + r) >> 1;    
        if (L <= m) update(L , R , c , lson);    
        if (m < R) update(L , R , c , rson);    
        PushUp(rt);    
    }    
    LL query(int L,int R,int l,int r,int rt) {    
        if (L <= l && r <= R) {    
            return sum[rt];    
        }    
        PushDown(rt , r - l + 1);    
        int m = (l + r) >> 1;    
        LL ret = 0;    
        if (L <= m) ret += query(L , R , lson);    
        if (m < R) ret += query(L , R , rson);    
        return ret;    
    }    
    int main() {    
        int N , Q;    
        scanf("%d%d",&N,&Q);    
        build(root);    
        while (Q --) {    
            char op[2];    
            int a , b , c;    
            scanf("%s",op);    
            if (op[0] == ‘Q‘) {    
                scanf("%d%d",&a,&b);    
                printf("%lld\n",query(a , b ,root));    
            } else {    
                scanf("%d%d%d",&a,&b,&c);    
                update(a , b , c , root);    
            }    
        }    
        return 0;    
    }    

树状数组（转载）