狠狠色丁香久久婷婷综合_中 ,国产精品久久久久久久久软件,精品少妇人妻av无码久久

dynamic programming

micheal's tech — Thu, 17 May 2012 01:54:00 GMT

感觉动态规划中最隄��部分是在��L�� 从状态j到状态i的递归式，��像证明归纳法一��P��你得扑և�具体的式子来�?br />top bottom
bottom up
1. Longest Increasing Subsequence:
L[i] = max(1+L(j))(j
//if not exist any a[j]
L[i] = 1;

getmaxvalueof array a[]

2. Maximum Sum Increasing Subsequence
almost same with above

3. Maximum continous sum

4. rod cutting

micheal's tech 2012-05-17 09:54 发表评论

micheal's tech — Tue, 18 Nov 2008 03:20:00 GMT

贪心法的基本思�\�Q?

从问题的某一个初始解出发逐步��D��l�定的目标，以尽可能快的地求得更好的解。当辑ֈ�某算法中的某一步不能再�l�箋前进�Ӟ��法停止�?
该算法存在问题：
1. 不能保证求得的最后解是最佳的�Q?
2. 不能用来求最大或最��解问题�Q?
3. 只能求满��x��些约束条件的可行解的范围�? 实现该算法的�q�程�Q?
从问题的某一初始解出发；

while 能朝�l�定�ȝ��标前�q�一�? do
求出可行解的一个解元素�Q?
由所有解元素�l�合成问题的一个可行解

贪心��法最�l�典的例子，�l�钱问题�?
比如中国的货币，只看元，�?�?�?�?0�?0�?0�?00

如果我要16元，可以�?6�?元，8�?元，但是怎么最��呢�Q?
如果用贪心算�Q�就是我每一�ơ拿那张可能拿的最大的�?
比如16�Q�我�W�一�ơ拿20拿不��P��?0元，OK�Q�剩�?元，再拿�?元，剩下1�?
也就�?�? 10�?�?�?

每次拿能拿的最大的�Q�就是贪心�?

但是一定注意，贪心得到的�ƈ不是最优解�Q�也��是说用贪心不一定是拿的最��的张数
贪心只能得到一个比较好的解�Q�而且贪心��法很好惛_��到�?
再注意，��Z��么我们的钱可以用贪心呢？因�ؓ我们国家的钱的大��设计，正好可以使得贪心��法��出来的是最优解�Q�一般是个国家的钱币都应该这么设计）。如果设计成别的样子情况��׃��同了
比如某国的钱币分�? 1�?�?�?
如果要拿6元钱怎么拿？贪心的话先拿4 再拿两个1 一�?张钱
实际最优呢�Q? 两张3元就够了

求最优解的问题，从根本上说是一�U�对解空间的遍历。最直接的暴力分析容易得刎ͼ�最优解的解�I�间通常都是以指数阶增长�Q�因此暴力穷��N��是不可行的�?/div>

最优解问题大部分都可以拆分成一个个的子问题�Q�把解空间的遍历视作对子问题树的遍历�Q�则以某�U��Ş式对树整个的遍历一遍就可以求出最优解�Q�如上面的分析，�q�是不可行的�?/div>

贪心和动态规划本质上是对子问题树的一�U�修剪。两�U�算法要求问题都��h��的一个性质��是“子问题最优�?#8221;。即�Q�组成最优解的每一个子问题的解�Q�对于这个子问题本��n肯定也是最优的。如果以自顶向下的方向看问题树（原问题作根）�Q�则�Q�我们每�ơ只需要向下遍历代表最优解的子树就可以保证会得到整体的最�? 解。�Ş象一点说�Q�可以简单的用一个��|��最优��|��代表整个子树�Q�而不用去求出�q�个子树所可能代表的所有倹{�?/div>

动态规划方法代表了�q�一�c�问题的一般解法。我们自底向上（从叶子向根）构造子问题的解�Q�对每一个子树的根，求出下面每一个叶子的��|��q�且以其�? 的最优��g��w�的��|��其它的��D��弃。动态规划的代�h��取决于可选择的数目（树的叉数�Q�和子问题的的数目（树的节点敎ͼ�或者是树的高度�Q�）�?/div>

贪心��法是动态规划方法的一个特例。贪心特在，可以证明�Q�每一个子树的根的��g��取决于下面叶子的��|��而只取决于当前问题的状况。换句话��_��不需要知道一个节�Ҏ��有子树的情况�Q�就可以求出�q�个节点的倹{��通常�q�个值都是对于当前的问题情况下，显而易见的“最�?#8221;情况。因此用“贪心”来描�q�这个算法的本质。由于贪心算法的�q�个�Ҏ��，它对解空间树的遍历不需要自底向上，而只需要自根开始，选择最优的路，一直走到底��可以了。这��P��与动态规划相比，它的�? 价只取决于子问题的数目，而选择数目��Mؓ1�?/div>

micheal's tech 2008-11-18 11:20 发表评论

micheal's tech — Wed, 08 Oct 2008 07:01:00 GMT

#include
using namespace std;
#include
int MergeSort(int A[],int p,int q,int r)
{
    int n1 = q-p+2;
    int n2 = r-q+1;
    int *parray1 = new int[n1];
    int *parray2 = new int[n2];
    assert(parray1);
    assert(parray2);
    for(int i = 0;i    {
        parray1[i] = A[p+i];
    }
    parray1[n1-1] = 0xffff;
    for(int i = 0;i    {
        parray2[i] = A[q+i+1];
    }
    parray2[n2-1] = 0xffff;
    for(int i=0,j=0,k=p;k<=r;k++)
    {
        if(parray1[i]>parray2[j])
        {
            A[k] = parray2[j];
            j++;
        }
        else
        {
            A[k] = parray1[i];
            i++;
        }
    }

    delete []parray1;
    delete []parray2;

}
int Merge(int A[],int p,int r)
{
    if(p    {
       int q = (p+r)/2;
       Merge(A,p,q);
       Merge(A,q+1,r);
       MergeSort(A,p,q,r);
    }
}
int main()
{
    int a[]={5,2,4,7,1,3,2,6};
    Merge(a,0,sizeof(a)/sizeof(int)-1);
    for(int i=0;i<8;i++)
    {
        cout<    }
    cout<}

micheal's tech 2008-10-08 15:01 发表评论

散列函数

micheal's tech — Mon, 18 Aug 2008 03:26:00 GMT

��关键字转化��地址的函数称为散列函数。理想的散列函数易于转换�q�且是随机的�Q�这里的随机是指�Ҏ��一个输入，相应的输出在某种�E�度上是�{�概率的�?br>常用的散列函敎ͼ�适用于整敎ͼ�模散列函敎ͼ�k mod�Q�M)
适用于关键字为字�W�串的算法：霍纳��法�?br>散列最主要的优��性能在于能够提供�q�似于常数的旉��?br>

micheal's tech 2008-08-18 11:26 发表评论

micheal's tech — Tue, 22 Jul 2008 07:40:00 GMT

四则�q�算包括括号一般用栈来实现�?br>#include "stack.h"
#include
#include
using namespace std;

int main(int argc,char *argv[])
{
    //char *a = argv[1];
   // char *a = "(((2*(3-3))+5)*3)";
    char *a = "4*3-2";
    size_t len = strlen(a);

    //the operation value
    MyStack opv(128);
    //the opeartion transfer
    MyStack opt(128);

    for(int i=0;i    {
        if((a[i]>='0')&&(a[i]<='9'))
                //cout<        {
            opv.push(0);

        }
        while((a[i]>='0')&&(a[i]<='9'))
        opv.push(opv.pop()*10+a[i++]-'0');
        if(')'== a[i])
        {
            char c = opt.pop();
            if('*' == c)
            opv.push(opv.pop()*opv.pop());
            if('+' == c)
            opv.push(opv.pop()+opv.pop());
            if('-' == c)
            opv.push(-(opv.pop()-opv.pop()));
        }


        if(('-'== a[i])||('+' == a[i])||('*' == a[i]))
        {
            opt.push(a[i]);
        }
    }
    cout<

}

micheal's tech 2008-07-22 15:40 发表评论

内部排序的几�U�方法的比较

micheal's tech — Fri, 27 Jun 2008 08:01:00 GMT

内部排序的几�U�方法的比较
最坏时间复杂度 �q�_��旉��复杂�?nbsp; �I�间复杂�?nbsp; �E�_��排序其它特点
冒��排序
快速排�?br>
插入排序
shell排序

选择排序
堆排�?br>
归�ƈ排序

基数排序
http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.7.1.1.htm

micheal's tech 2008-06-27 16:01 发表评论

mykmp

micheal's tech — Thu, 26 Jun 2008 09:37:00 GMT

#include
using namespace std;
int getIndex(const char * p,int next[])
{
    if(p == NULL)
        return -1;
    int k = -1;
    int j = 0;
    next[0] = -1;
    while(p[j])
    {
        if(k==-1||p[k]==p[j])
        {
            ++j;
            ++k;
            if(p[k]!=p[j])
            {
                next[j] = k;
            }
            else
            {
                next[j] = next[k];
            }
        }
        else
        {
            k = next[k];
        }
    }
}

int kmpcompare(const char * srcstr,const char * deststr,int next[] )
{
    if(!srcstr ||!deststr||!next)
        return -1;
    int i = 0;
    int j = 0;
    while(srcstr[i]!='\0'&&deststr[j]!='\0')
    {
        if(srcstr[i] == deststr[j])
        {
            i++;
            j++;
        }
        else
        {
            if(next[j]!=-1)
            {
                j = next[j];
            }
            else
            {
                i++;
                j=0;
            }

        }
    }
    if(deststr[j] == '\0')
    {
        return i-j;
    }
    else
    {
        return -1;
    }

}

micheal's tech 2008-06-26 17:37 发表评论

micheal's tech — Mon, 16 Jun 2008 03:40:00 GMT

堆优化的�Ҏ��Q?br>1、自��向�?br>template
void fixDown(Item a[],int k,int N)
{
    Item temp;
    while(2*k <= N)
    {
        int j = 2*k;
        if (j        if (!(a[k]        //cout<<"fixdown"<        exch(a[k],a[j]);
        k = j;
    }
}
�Ҏ��堆是个完全二叉树�Q�把除了叶节点以外的从下往上逐步排好�?br>2、自底向�?br>template
void fixUp(Item a[],int k)
{
    while(k>1 && a[k/2]    {
        exch(a[k],a[k/2]);
        k = k/2;
    }
}

堆排排序的步骤，
1、徏立堆�?br>可以插入的方法或者采取修正堆的方法�?br> for(k=N/2;k>=l;k--)
    {
        fixDown(pq,k,N);
    }
2、逐步排序�?br>   while(N>l)
    {
        exch(pq[l],pq[N]);
        fixDown(pq,l,--N);
    }

�ȝ��法：
template
void heapsort(Item a[],int l,int r)
{
    int k = l,N = r-l+1;
    Item *pq = a+l-1;
    for(k=N/2;k>=l;k--)
    {
        fixDown(pq,k,N);
    }
    while(N>l)
    {
        exch(pq[l],pq[N]);
        fixDown(pq,l,--N);
    }

}

堆排序引申的题目�?br>如果需�?font color="#cc0033">扑և�N个数�?font color="#cc0033">最大的K�?/font>不同的数

�?em>N > K�Q�前K个数中的最�?em>K个数是一个退化的情况�Q�所�?em>K个数��是最大的K个数。如果考虑�W?em>K+1个数X呢？如果X比最大的K个数中的最��的�?em>Y��，那么最大的K个数�q�是保持不变。如�?em>X�?em>Y大，那么最大的K个数应该��L��Y�Q�而包�?em>X。如果用一个数�l�来存储最大的K个数�Q�每新加入一个数X�Q�就扫描一遍数�l�，得到数组中最��的�?em>Y。用X替代Y�Q�或者保持原数组不变。这��L��Ҏ��Q�所耗费的时间�ؓO�Q?em>N * K�Q��?/p>

�q�一步，可以用容量�ؓK的最��堆来存储最大的K个数。最��堆的堆��元素就是最�?em>K个数中最��的一个。每�ơ新考虑一个数X�Q�如�?em>X比堆��的元素Y��，则不需要改变原来的堆，因�ؓ�q�个元素比最大的K个数��。如�?em>X比堆��元素大�Q�那么用X替换堆顶的元�?em>Y。在X替换堆顶元素Y之后�Q?em>X可能破坏最��堆的结构（每个�l�点都比它的父亲�l�点大）�Q�需要更新堆来维持堆的性质。更新过�E�花费的旉��复杂度�ؓO�Q�log₂K�Q��?/p>

�?-1

�?-1是一个堆�Q�用一个数�l?em>h[]表示。每个元�?em>h[i]�Q�它的父亲结�Ҏ��h[i/2]�Q�儿子结�Ҏ��h[2 * i + 1]�?em>h[2 * i + 2]。每新考虑一个数X�Q�需要进行的更新操作伪代码如�?

代码清单2-13

if(X > h[0])

{

h[0] = X;

p = 0;

while(p < K)

{

q = 2 * p + 1;

if(q >= K)

break;

if((q < K – 1) && (h[q + 1] < h[q]))

q = q + 1;

if(h[q] < h[p])

{

t = h[p];

h[p] = h[q];

h[q] = t;

p = q;

}

else

break;

}

因此�Q�算法只需要扫描所有的数据一�ơ，旉��复杂度�ؓO�Q?em>N * log₂K�Q�。这实际上是部分执行了堆排序的算法。在�I�间斚w��Q�由于这个算法只扫描所有的数据一�ơ，因此我们只需要存储一个容量�ؓK的堆。大多数情况下，堆可以全部蝲入内存。如�?em>K仍然很大�Q�我们可以尝试先找最大的K’个元素，然后扄��K’+1个到�W? * K’个元素，如此�c�L��Q�其中容�?em>K’的堆可以完全载入内存�Q�。不�q�这��P��我们需要扫描所有数据ceil�Q?em>K/K’�Q�次�?/p>

micheal's tech 2008-06-16 11:40 发表评论

快排分析

micheal's tech — Mon, 16 Jun 2008 03:40:00 GMT

快排分析 �Q�快排与冒��排序是相兌��的�?br>template
bubblesort(T *src,int lne)
{

}
前者是通过盔R��之间交换的方式来�?br>而后者是通过一个值得比较来交换的方式�?br>
template
void quicksort(T *src,int low,int high)
{
    T temp;
    int i = low;
    int k = high;
    if(low >=high) return;
    temp = src[low];

    while(low    {
        while(low=temp) high--;
        src[low] = src[high];
        while(low        src[high] = src[low];
    }
    src[low] = temp;
    quicksort(src,i,low-1);
    quicksort(src,low+1,k);
}

micheal's tech 2008-06-16 11:40 发表评论

micheal's tech — Mon, 16 Jun 2008 03:39:00 GMT

B树原�?

micheal's tech 2008-06-16 11:39 发表评论

micheal's tech — Mon, 16 Jun 2008 03:26:00 GMT

二叉搜烦树的随机化徏立方�?
二叉搜烦数是一��二叉树�Q�其中每一个内部节炚w��有一个相关的关键字，�q�有负有以下的性质。�Q意节点的关键字大于（或者等于）该节点左子树的所有关键字�Q��ƈ��于�Q�或者等于）该节点右子树的所有关键字�?br>

#include <stdlib.h>
#include <iostream.h>
static int maxKey = 1000;
typedef int Key;
class Item{
    private:
        Key keyval;
        float info;
    public:
        Item()
        {keyvalue = maxKey;}
        Key key()
        {return keyvalue;}
        int null()
        {
            return keyvalue  ==maxKey;
        }
        void rand()
        {
            keyval = 1000*::rand()/RAND_MAX;
        }
        int scan(istream& is=cin)
        {
            return(is>>keyvalue>>info )!=0);
        }
        void show(ostream& os=cout)
        {
            os<<keyvalue<<" "<<info<<endl;
        }
};
ostream& operator<<(ostream &os,Item &X)
{
    X.show(os);
    return os;
}

template <class Item,class Key>
class ST
{
    private:
        struct node
        {
            Item item;
            node *l,*r;
            node(Item x)
            {
                item = x;
                l = 0;
                r = 0;
            }
        };
        typedef node * link;
        link head;
        struct node nullitem;

        void insertR(link &h,Item x)
        {
            if(h == 0)
            {
                h = new node(x);
                return;
            }
            if(x.key()<h->item.key())
            {
                insertR(h->l,x);
            }
            else
            {
                insertR(h->r,x);
            }

        }
        Item searchR(link &h,Key v)
        {
            if(h == 0)
                return nullitem;
            if(h->item.key() == v)
            {
                return h->Item;
            }
            else if(h->item.key()<v)
            {
                searchR(h->right,v);
            }
            else
            {
                searchR(h->left,v);
            }

        }

        }
    public:
        ST(int)
        {
        }
        int count();
        Item search(Key);
        void insert(Item);
        void remove(Item);
        Item select(int);
        void show(ostream &);
};

micheal's tech 2008-06-16 11:26 发表评论

micheal's tech — Mon, 16 Jun 2008 02:57:00 GMT

摘要: 转蝲比较详细 ... 阅读全文

micheal's tech 2008-06-16 10:57 发表评论

后序遍历的递归和非递归��法

micheal's tech — Sun, 15 Jun 2008 06:37:00 GMT

后序的递归��法�?br>template
void recposttraverse(struct node* Tree)
{
    if(Tree == NULL) return;
    recposttraverse(Tree->left);
    recposttraverse(Tree->right);
    visitnode(Tree);
}
后序的非递归��法要加入tag的实现�?br>template
void posttraverse(struct node*tree)
{
    if(tree == NULL) return;
    MyStack *> treestack;
    treestack.init(20);
    treestack.push(tree);
    struct node* Item;
    while(treestack.gettop()!=0)
    {
        Item = treestack.pop();
        if(Item&&Item->flag)//true is tree
        {
            Item->flag = false;
            treestack.push(Item);
            if(Item->right)
            treestack.push(Item->right);
            if(Item->left)
            treestack.push(Item->left);
        }
        else
        {
            visitnode(Item);
        }

    }

}

micheal's tech 2008-06-15 14:37 发表评论

中序遍历的递归��法和非递归��法

micheal's tech — Sun, 15 Jun 2008 06:35:00 GMT

中序遍历的递归��法和非递归��法�?br>template
void recitraverse(struct node* Tree)
{
    if(Tree == NULL) return;
    itraverse(Tree->left);
    visitnode(Tree);
    itraverse(Tree->right);
}
中序遍历的非递归��法visit节点时与前序不同�?br>template
void itraverse(struct node*tree)
{
    if(tree == NULL) return;
    MyStack *> treestack;
    treestack.init(20);
    while(tree != NULL|| treestack.gettop()!=0)
    {
        if(tree!=NULL)
        {
            treestack.push(tree);
            tree = tree->left;
        }
        else
        {
            tree = treestack.pop();
            visitnode(tree);
            tree = tree->right;

        }
    }

}

micheal's tech 2008-06-15 14:35 发表评论

前序遍历二叉树的递归和非递归��法

micheal's tech — Thu, 05 Jun 2008 14:20:00 GMT

递归��法和非递归��法本质是一��L��?br>遍历时从根节点开始访问，讉K��左子树，关键是把树的讉K��序搞清楚�?br>当遍历完以后又是根节炏V�?br>
递归函数实际上就是栈的操作�?br>所谓的先根��是先visit完根节点�Q�然后再遍历左子树，遍历叛_��树�?br>
template
void recpretraverse(struct node*&Tree)
{
    if(Tree == NULL) return;
    visitnode(Tree);
    recpretraverse(Tree->left);
    recpretraverse(Tree->right);
}

对应的非递归��法��是弹出��，看如果是树，如果叛_��树存在则压入叛_��树，左子树存在则压入左子树，最后压入节点（tag域变化）�?br>                            看如果是节点�Q�则讉K��节点�?br>可以看出需要一个tag域来表示弹出节点�q�是树。但是前序和中序可以通过别的实现办法避免tag实现�?br> template
void pretraverse(struct node*tree)
{
    if(tree == NULL) return;
    MyStack *> treestack;
    treestack.init(20);
    while(tree != NULL|| treestack.gettop()!=0)
    {
        if(tree!=NULL)
        {
            treestack.push(tree);
            visitnode(tree);
            tree = tree->left;
        }
        else
        {
            tree = treestack.pop();
            tree = tree->right;

        }
    }

}

micheal's tech 2008-06-05 22:20 发表评论