��法相关的网址

Cunch — Wed, 09 Jan 2013 04:46:00 GMT

http://www.csie.ntnu.edu.tw/~u91029/ 台湾的国立师范大�?/p>

http://www.notonlysuccess.com/ 国内搞ACM�?/p>

http://www.keithschwarz.com/ 一个老外用STL实现的算法代�?/p>

http://www.possibility.com/Cpp/CppCodingStandard.html CPP代码规范

Cunch 2013-01-09 12:46 发表评论

一个牛逼的快排

Cunch — Fri, 26 Aug 2011 08:39:00 GMT

void qs(int l,int r){
   long  k,m;
  if(l>=r)
  return;
  yd(((l+r)/2),r);
  m=l-1;
  for(k=l;k
  if(a[k]
        m++;
        yd(k,m);
    }
    yd((m+1),r);
    qs(l,m);
    qs((m+2),r);
}
void yd(int x,int y){
    long temp;
    temp=a[x];
    a[x]=a[y];
    a[y]=temp;
}

Cunch 2011-08-26 16:39 发表评论

Cunch — Tue, 08 Mar 2011 03:29:00 GMT

今天主要是想回忆下DFS�Q�所以就那全排列开刀了，自己写了一个发现网上的解法真不错就��x�ȝ��下：

一、利用DFS实现�Q�自己写的）
废话��׃��说了上代码：

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

const int size = 20;

bool visited[20];
int  arr[20];

int n;

void dfs(int cnt)
{
    if( cnt == n)
    {
        for(int i = 0; i < n; ++i)
        {
            cout << arr[i] << " " ;
        }
        cout << endl;
    }
    else
    {
        for(int i = 1; i <= n; ++i )
        {
            if(!visited[i])
            {
                arr[cnt] = i;
                visited[i] = 1;
                dfs(cnt+1);
                visited[i] = 0;
            }
        }
    }
}

int main()
{

    while(cin>>n)
    {
        memset(visited, 0, sizeof(visited));
        dfs(0);
    }

    return 0;
}

�q�种�Ҏ��,我没有想好怎么实现含有相同元素的全全排�?br>
二、利用递归实现�Q�其实还是DFS�Q�只是实现的�Ҏ��不一��P��但是它能够实现含有相同元素的全排�?br>下面�l�一�D늽�上找的解释，其实王晓东的那本《算法与设计》有�q�个�Q?br>令E={e1,e2...en}表示n个元素的集合�Q�我们的目标是生成该集合的所有排列方式。��oEi为E中移��d��素i以后所获得的集�?perm�Q�X�Q�表�C�集合X中元素的排列方式�Q�ei.perm(X)表示在perm(X)中的每个排列方式的前面均加上ei以后所得到的排列方式。例如，如果E={a,b,c},那么E1 = {b,c},perm(E1) = (bc,cb),e1.perm(E1) = (abc,acb)�?

对于递归的基本部�?采用n=1。当只有一个元素时,只可能��生一�U�排列方�?所以perm(E) = (e)�Q�其中e是E中的唯一元素。当n>1�Ӟ��perm(E) = e1.perm(E1) + e2.perm(E2)+ e3.perm(E3�Q?.......+en.perm(En)。这�U�递归定义形式是采用n个perm(X)来定义perm(E)�Q�其中每个X包含n-1个元素。至此，一个完整的递归定义所需要的基本部分和递归部分都已完成�?br>
下面�l�出我自己写的代码：

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

template<class T>

void sswap(T &a, T &b)
{
    if( a != b )
    {
        int tmp = a;
        a = b;
        b = tmp;
    }
}

template<class T>
void Perm(T list[], int k, int m)
{
    if(k == m)
    {
        for(int i = 0; i <= m; ++i)
        {
            cout << list[i] << "";
        }
        cout << endl;
    }
    else
    {
        for(int i = k; i <= m; ++i)
        {
           // if( (list[k] != list[i]) || (k == i) ) //��Z��实现相同元素的全�?br>           // {
                sswap(list[k], list[i]);
                Perm(list, k+1, m);
                sswap(list[k], list[i]);
            //}
        }
    }
}

int main()
{
    int n;
    int arr[10];

    while(cin>>n)
    {
        for(int i = 0; i < n; ++ i)
        {
            cin>>arr[i];
        }

        Perm(arr, 0, n - 1);
    }

    return 0;
}

三、压��_��STL next_permutation
下面是网上的一�D�分�?br>

C++/STL中定义的next_permutation和prev_permutation函数则是非常灉|��且高效的一�U�方法，它被�q�泛的应用于为指定序列生成不同的排列。本文将详细的介�l�prev_permutation函数的内部算法�?/p>

　　按照STL文档的描�q�ͼ�next_permutation函数��按字母表顺序生成给定序列的下一个较大的排列�Q�直到整个序列�ؓ降序为止。prev_permutation函数与之相反�Q�是生成�l�定序列的上一个较��的排列。二者原理相同，仅遍例顺序相反，�q�里仅以next_permutation��Z��介绍��法�?/p>

　　先对序列大小的比较做出定义：两个长度相同的序列，从两者的�W�一个元素开始向后寻找，直到出现一个不同元素（也可能就是第它们的第一个元素）�Q�该元素较大的序列�ؓ大，反之序列为小�Q�若一直到最后一个元素都相同�Q�那么两个序列相�{��?/p>

　　讑ֽ�前序列�ؓpn�Q�下一个较大的序列为pn+1�Q�这里蕴藏的含义是再也找不到另外的序列pm�Q��得pn < pm < pn+1�?/p>

　　问题

　　�l�定��L��非空序列�Q�生成下一个较大或较小的排列�?/p>

　　�q�程

　　�Ҏ��上述概念易知�Q�对于一个�Q意序列，最��的排列是增序，最大的为减序。那么给定一个pn要如何才能生成pn+1呢？先来看下面的例子�Q?/p>

　　�? 6 4 2为pn�Q�下一个序列pn+1应该�? 2 3 6。观察第一个序列可以发现pn中的6 4 2已经为减序，在这个子集中再也无法排出更大的序列了�Q�因此必��ȝ��?的位�|�且要找一个数来取�?的位�|�。在6 4 2�?�?都比3大，�?�?大的太多了，只能�?。将4�?的位�|�对调后形成排列4 6 3 2。注意，�׃��4�?大小的相��d��p�，对调后��生的子集6 3 2仍保持逆序�Q�即该子集最大的一�U�排列。�?是第一�ơ移动到头一位的�Q�需要后面的子集为最��的排列�Q�因此直接将6 3 2倒�{�? 3 6便得��C��正确的一个序列pn+1�?/p>

　　下面归纳分析该过�E�。假设一个有m个元素的序列pn�Q�其下一�l�较大排列�ؓpn+1�Q?/p>

　　若pn的最后的2个元素构成一个最��的增序子集�Q�那么直接反转这2个元素��该子集成为减序即可得到pn+1。理由是pn和pn+1的前面m-2个元素都相等�Q�没有对前面的元素进行操作）�Q�仅能靠最�?个元素来分出大小。而这2个元素只能出�?�U�排列，其中较大的一�U�是减序�?/p>

　　若pn的最后最多有s个元素构成一个减序子集，令i = m - s�Q�则有pn(i) < pn(i+1)�Q�因此若��pn(i)和pn(i+1)调换必能得到一个较大的排列�Q�不一定是下一个）�Q�因此必��M��持pn(i)之前的元素不动，�q�在子集{pn(i+1), pn(i+2), ..., pn(m)}中找��C��个仅比pn(i)大的元素pn(j)�Q�将二者调换位�|�。此时只要得到新子集{pn(i+1), pn(i+2), ..., pn(i), ...,pn(m)}的最��排列即可。注意到新子集仍保持减序�Q�那么直接将其反转即可得到最��的增序子集�?/p>

　　按以上步骤便可从pn得到pn+1了�?/p>

　　复杂�?/p>

　　最好的情况为pn的最后的2个元素构成一个最��的增序子集�Q�交换次��Cؓ1�Q�复杂度为O(1)�Q�最差的情况�?个元素最��，而后面的所有元素构成减序子集，�q�样需要先��第1个元素换到最后，然后反�{后面的所有元素。交换次��Cؓ1+(n-1)/2�Q�复杂度为O(n)。这样��^均复杂度即�ؓO(n/2)�?/p> //STL的生成方�?br>bool my_next_permutation(int * const begin, int * const end)
{
    int *p1 , *p2;
    for(p1 = end - 1; p1!= begin; p1--)//扑ֈ�序列中从后往前第一个元�?��于元素2的一�?br>    {
        if(*(p1-1)< *(p1))
            break;
    }
    if(p1==begin)//�q�种情况下序列已�l�完全逆序
        return false;
    p1--;//使p1指向��的那个�?br>    for(p2 = p1 + 1; p2 != end; p2++)//��L��p1后面比p1��但是最大的那个�?br>    //�Q�这里利用了后面序列降序的性质
    {
        if(*p2 < *p1)
            break;
    }
    p2--;//p2指向后面比p1大但是最��的那个
    iter_swap(p1,p2);//交换p1�Q�p2指向的元�?br>    reverse(p1+1,end);//注意是到end 反向而非p2
    return true;
}

误��栯��?/p>

view plaincopy to clipboardprint?
do
{
    for(int i = 0; i < MAX; i++)
    {
        cout << d[i] << " ";
    }
    cout << endl;
}while(my_next_permutation(d,d+MAX));
    do
    {
        for(int i = 0; i < MAX; i++)
        {
            cout << d[i] << " ";
        }
        cout << endl;
    }while(my_next_permutation(d,d+MAX));

部分内容引用�Q?a >http://blog.csdn.net/heartnheart/archive/2010/10/20/5953150.aspx

Cunch 2011-03-08 11:29 发表评论

精品久久久久久,国产精品丝袜久久久久久不卡,久久精品中文字幕久久

���法相关的网址

一个牛逼的快排

��法相关的网址