杂耍算法

出处：http://www.cnblogs.com/solidblog/archive/2012/07/15/2592009.html

1.前言

我的第一篇文章：编程珠玑（一）：前言 && 位图排序，从发布以来到目前为止已经被浏览了超过一千次。

有几个朋友进行了回复，都是给予支持和鼓励的。在此，对这些朋友表示感谢！

学习本来就是一件需要耐心和毅力的事情，各种滋味只有同道中人才能理解。

同时，学习也是一件能够带给快乐和成就感的事情：

    当你搞懂一个算法、理解一个原理时候，其中的喜悦不亚于盛夏的冷饮，寒冬的暖炉。

 多谢朋友们，我会继续努力的，为了自己也为了对某个人的承诺！

2.问题描述

          请将一个具有n个元素的一维向量x向左旋转i个位置。例如，假设n=8， i=3，那么向量abcdefgh旋转之后得到向量defghabc。

3.解决思路

1. 普通方法
   步骤如下：
   1）设法将向量x中的前i个元素复制到一个临时数组中
   2）将余下的n-i个元素左移i个位置
   3）将前i个元素从临时数组中复制回x中的后面位置
   简单的实现了一下，代码如下：

View Code 
 #include <stdio.h>
 
 void Rotate(char *a, int length, int i)
 {
     char tmp[10];
     int step = i % length;
     if (step == 0)
     {
         return;
     }
 
     int j = 0;
 
     for (j = 0; j < step; j++)
     {
         tmp[j] = a[j];
     }
     tmp[step] = '\0';
 
     for (j = step; j < length; j++)
     {
         a[j -step] = a[j];
     }
 
 
     j = 0;
     while((a[length - step + j] = tmp[j]) != '\0')
     {
         j++;
     }
 }
 
 void main()
 {
     char a[9] = "abcdefgh";
     Rotate(a,8,3);
     printf("%s",a);
 }

1. 不足：
   这个方案使用了i个额外的位置，这使得它太浪费空间了。

2. 杂耍算法
   先上解决方法，详细分析我们稍后奉上
   步骤如下：
   1）先将x[0]移到临时变量t中
   2）将x[i]移动到x[0]中，x[2i]移动到x[i]中，依次类推
   3）将x中的所有下标都对n取模，直到我们又回到从x[0]中提取元素。不过这时我们从t中提取元素，结束。
   代码如下：

#include<stdio.h>

//使用辗转相除法求最大公约数
int gcd(int a, int b)
{
    if (a % b == 0)
    {
        return b;
    }
    else
    {
        return gcd(b, a%b);
    }
}

//杂耍算法
void rotate(char* a,int n,int i)
{
    int step = gcd(n,i);
    for(int j = 0; j < step; j++)
    {
        int temp = a[j];
        int current = j;
        while(1)
        {
            int next= (current + i) % n;
            if(next== j) 
            {
                break;
            }
            a[current] = a[next];
            current= next;
        }
        a[current] = temp;
    }
}

int main()
{
    char a[9] = "abcdefgh";
    rotate(a,8,3);

    printf("%s\n",a);
    return 0;
}

3、说实话，这个算法理解起来还是有一定的难度的，想要把原理搞懂还是需要下点功夫的。
下面就让我们一起来分析一下这个算法吧，准备好了吗，我们开始了！

两个整数的最大公约数是能够同时整除它们的最大的正整数。辗转相除法基于如下原理：

两个整数的最大公约数等于其中较小的数和两数的差的最大公约数。

我们来看一下这个原理的证明：

   设两数为a、b(b<a），用gcd(a,b）表示a，b的最大公约数。
r=a mod b，r为a除以b以后的余数，辗转相除法即是要证明gcd(a,b)=gcd(b,r）。

    证明步骤如下：

1）令c=gcd(a,b），则设a=mc，b=nc

2）r = a mod b，所以r = a - k*b = mc - k*nc = (m - kn) * c。即，r = (m - kn) * c

3）由r = (m - kn) * c 可知：c也是r的因数

4）可以肯定m - kn与n互质（why？)

   假设他们不互质，必然存在大于1的整数d，使得m-kn = xd, n = yd。那么，m = xd + kyd = (x + ky)d

   那么，a = mc = (x + ky)dc , b = nc = ydc 。=> a,b的最大公约数为dc，而不是c。

5）既然m - kn与n互质，所以c = gcd(r,b)。

结论，gcd(a,b)=gcd(b,r）

（辗转相除法更详细的描述请参照百度百科：http://baike.baidu.com/view/255668.htm。）

5.杂耍算法

杂耍算法中如下两点我无法理解：

1.为什么程序要循环执行gcd(i,n)次
2.这个算法是通过什么样的机制就让所有位置上的元素都移动到了预期的位置

程序的走向我是明白的，但是核心算法始终不得其解。
最终还是需要借助网络，搜到了园子内一位朋友写的文章（关于编程珠玑中习题2.3的一点思考）
看完以后，有种豁然开朗的感觉，在此多谢这个朋友了。

不过，那篇文章中有些概念的细节讲的不是太清楚，我也是借助网络才有了更清晰的了解。
再次，我来总结个精简吧的吧，写的不好还请各位包涵！

先从几个概念开始：

1. 同余
   如果两个整数（a，b）除以同一个整数m，如果得到相同的余数k。则称a，b对于模m同余。
    记作a ≡ b (mod m)
2. 同余类
   所谓同余类是指以某一特定的整数（如m）为模，按照同余的方式对全体整数进行的分类。
   对给定的模m，有且恰有m个不同的模m的同余类。它们是：
      0 mod m，1 mod m，…，（m-1）mod m。
3. 完全剩余类
   通过2）我们知道，所有的整数以m为模可以划分为m个没有交集的集合。
   从每个集合中取一个整数组成一个集合，则这个集合中的m个整数就不存在同余的整数，这个集合就叫做完全剩余类。

了解了以上三个概念后，我们能够得出如下的结论：

如果i和n互质，那么序列：
    0   i mod n     2i mod n    3i mod n    …… （n-1）*i mod n
就包括了集合{0,1,2,……n-1}的所有元素 

我们为什么会有这样的结论呢，下面来证明一下

前提条件

   对于模n来说，序列0,1,2，……，n-1本身就是一个完全剩余类（即他们之间两两互不同余）

证明步骤

1）从此序列中任取两个数字xi，xj（0 <= i,j <= n-1）,则有Xi≠Xj (mod n),   注：这里由于不能打出不同余字符因此用不等于替代

2）由于i和n是互质的，所以 xi * i ≠ xj * i(mod n)
    =》这就说明，xi从0开始一直取值到n-1，得到的序列0 * i，1 * i，2 *i，……（n-1）*n就是一个完全剩余类。即集合0,1,2,……n-1}

有了以上的结论，如果i和n互质，下面的赋值过程便能完成所有位置的值的移动：
    t = X[0]
    X[0] = X[i mod n]
    X[i mod n] = X[2i mod n]
    …….
    X[(n-2)*i mod n] = X[(n-1)*i mod n]
    X[ (n-1)*i mod n] = t
以上的赋值操作，赋值操作符的两边都得到了一个完全剩余类，也就是说所有的0 ~ n-1的所有位置都被移动过了
请注意第二个操作，X[0] = X[i mod n]。
    该操作决定了整体的导向，该操作将i mod n位置的值移动到了最开始的位置。
    由于i，2i，……之间的偏移量是相同的，所以整个操作实际上就是讲序列向左移动i个位置（超过了开始位置的接到最右边去）

那么如果i和n不互质呢?

自然的想法是利用我们已经得到的结论，让i和n互质，即让i’ = i/(gcd(i,n))，n’ = n/(gcd(i,n))。

这样便构造了一对互质的数, i’和n’。这意味着把整个数组的每g=gcd(i,n)个元素组成块。

由于我们的单位是块元素，每次相当于把g中的一个元素移到最终位置上，所以总共需要g次移动。