随机排列生成算法的一些随想

这篇文章主要是一个闲文。如果您正在寻求一个理想的随机排列生成算法,直接阅读方法3,或是直接使用STL里提供的random_shuffle()方法
另外请注意,这里所讨论的算法并不是新的。

什么是随机排列? 

一个随机排列是一组位于随机位置的对象。
给定一个对象,1, 2, 3 ... n,随机排列看起来就是,
p1, p2, p3 ... pn
其中px是从原来的对象集合中选取的随机值。

随机排列对于扑克牌洗牌,随机产生益智游戏,产生随机序列,或者生成一个随机子集合集(从 n 个对象中随机选出 k 个对象),非常有用。

随机排列生成算法从天真到成熟,我的真实经验 

为了解释算法,我会用一个辅助函数来产生随机数。
int random(int min, int max);
其结果是一个大于或等于 min 且小于 max 的一个随机数。
也就是说,结果是位于左闭右开区间内。

方法1,天真的方式

 

在随机位置交换两个元素。重复足够的次数。

伪代码:

Cpp代码   收藏代码
  1. array data(1..n);  
  2. for(enough iterations) {  
  3.   swap(data[random(0, n)], data[random(0, n)]);  
  4. }  

 

这种方法非常直观,很简单,它真的有效,前提是有足够的迭代,比如对10个元素迭代100次。没错,它真的可以工作,我用过很多次。

但最大的问题是,迭代次数要远远高于对象数(N),因为在两次中选择相同位置的两个元素的概率是相当大的,概率为1 /(n * n)相当的高。
因此,用这种方法,我们要么得到糟糕的性能(使用非常高的迭代),要么是比较差的随机性(低迭代)。

方法2,从篮子里取小球

 

假设所有的对象都是球。我们把所有的球到一个篮子,然后从篮子里随机拿出一个球,如是重复直到篮子变空。

伪代码:

Cpp代码   收藏代码
  1. array data(1..n);  
  2. basket = new array;  
  3. for(i = 0 to N - 1) {  
  4.   basket.push(data[i]);  
  5. }  
  6. for(i = 0 to N - 1) {  
  7.   int index = random(0, basket.length);  
  8.   data[i] = basket[index];  
  9.   basket.remove(index);  
  10. }  

 

这种方法也很直观,因为在现实中,彩票抽奖正是用这种方法,而且用的是真正的篮子和球。
而且这种方法性能很好,具有O(n)的时间复杂度。
理论上,其结果是能保证足够随机的,因为所有的球是从篮子里随机选择。

方法3,演进 - 在篮球里原地选择

 

第二种方法是很好的实现,而且很容易操作。但是,在计算机世界中,它有一个缺点:它需要一个额外的临时缓冲区来作为篮子。
在大多数情况下这没什么,不是个问题,但我们是否可以做得更好呢?
当然可以!我们可以在就在篮子里选择。

实际的 C++ 代码:

Cpp代码   收藏代码
  1. int random(int minValue, int maxValue)  
  2. {  
  3.     assert(minValue <= maxValue);  
  4.    
  5.     if(minValue != maxValue) {  
  6.         return rand() % (maxValue - minValue) + minValue;  
  7.     }  
  8.     else {  
  9.         return minValue;  
  10.     }  
  11. }  
  12.    
  13. template <typename T>  
  14. void randomPermutation(T & data, int count)  
  15. {  
  16.     using std::swap;  
  17.    
  18.     for(int i = 0; i < count; ++i) {  
  19.         swap(data[i], data[random(i, count)]);  
  20.     }  
  21. }  

 

C 版本的非模板randomPermutation(用你需要的数据类型替换 "int" ,并自行实现 swap 函数)

Cpp代码   收藏代码
  1. void randomPermutation(int * data, int count)  
  2. {  
  3.     for(int i = 0; i < count; ++i) {  
  4.         swap(&data[i], &data[random(i, count)]);  
  5.     }  
  6. }  

 

上面的代码正是篮子方法的实现,不过比较隐晦。

了解原理

 

让我们假设篮子是有N个槽的长形篮子。则篮子是线性的。
那么初始篮子的样子,
1,2,3,4,5,6,...,N
现在假设我们随机选择5,那么篮子里的样子,
1,2,3,4,E,6,...,N
E表示空的槽。
接下来我们不删除E,我们把 5 之前的所有槽向后移动一个位置,并把 5 放在第一个槽里
5,1,2,3,4,6,...,N
下次如果我们选择3,我们只是移动 3 之前 5 之后的所有槽,然后把3个在那里,
5,3,1,2,4,6,...,N
重复N次

很好,是吗?我们不需要一个额外的缓冲区。但是,我们必须移动很多槽,不好玩。
如果第 C 次选择,我们只是把候选的元素与第 C 个元素交换,怎么样?
上面的迭代会进行以下变化,
1, 2, 3, 4, 5, 6, ..., N // 初始
5, 2, 3, 4, 1, 6, ..., N // 随机选择 5, 和 1 交换
5, 3, 2, 4, 1, 6, ..., N // 随机选择 3, 和 2 交换

这正是上面代码做的事情。


原文地址:http://kbasm.iteye.com/blog/1050113

### 关于贪心算法的讲解 贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择,从而希望最终结果也是全局最优的一种算法策略[^1]。 对于某些特定问题而言,这种局部最优解能够直接导向全局最优解。然而,并不是所有的优化问题都能通过这种方法求得最精确的结果,但在很多情况下可以获得接近最优解的有效方案。 #### 示例一:最大和转换后的数组元素(Java) 考虑这样一个例子,在给定整数列表`nums`以及一个非负整数`k`的情况下,允许执行最多`k`次操作来改变任意数量的数值符号。目标是在不超过`k`次翻转的前提下最大化所有元素之和: ```java class Solution { public int largestSumAfterKNegations(int[] nums, int k) { Arrays.sort(nums); int count = 0; for (int i = 0; i < nums.length; i++) { if (k > 0 && nums[i] < 0) { nums[i] = -nums[i]; k--; } count += nums[i]; } Arrays.sort(nums); return count - ((k % 2 == 0) ? 0 : 2 * nums[0]); } } ``` 这段代码实现了上述逻辑,其中先对输入数组进行了升序排列以便优先处理负值较大的项,之后再根据剩余的操作次数决定是否调整最小正值以进一步提升总和[^2]。 #### 示例二:分配最少糖果数目 另一个典型的应用场景涉及向一群孩子分发糖果,条件是一个孩子的评分高于其左侧邻居,则该名学生应获得更多的糖果。这里采用了一种简单直观的方法——每当遇到更高的分数就增加一颗糖的数量直到遍历结束整个序列为止[^3]。 ```python def distribute_candies(ratings): n = len(ratings) candies = [1]*n for i in range(1,n): if ratings[i]>ratings[i-1]: candies[i]=candies[i-1]+1 for j in reversed(range(n-1)): if ratings[j]>ratings[j+1] and candies[j]<=candies[j+1]: candies[j]=candies[j+1]+1 return sum(candies) ``` 此Python函数展示了如何利用两次扫描过程分别从前至后和从后往前更新每个位置上的最低需求量,确保满足题目要求的同时使得总的糖果消耗达到最小化。 #### 示例三:寻找合适的起始站点完成环形路线旅行 最后来看一个更复杂的案例—解决“加油站”问题。假设存在一系列相连的服务区构成闭合路径,车辆可以在任一站加油并继续行驶直至下一个目的地。为了判断能否顺利完成一圈旅程,可以通过计算各段行程结束后所剩燃油量来进行评估。具体做法是从第一个节点开始累积净增益(`gas-cost`),只要中途未曾跌入负区间即表明可以从起点出发成功返回原点;反之则需重新选定其他候选作为新的出发点尝试验证[^4]。 ```cpp bool canCompleteCircuit(vector<int>& gas, vector<int>& cost) { int total_tank = 0, curr_tank = 0, starting_station = 0; for (size_t i=0 ; i<gas.size() ; ++i){ total_tank += gas[i]-cost[i]; curr_tank += gas[i]-cost[i]; // If one couldn't get here, if(curr_tank < 0){ // Start over from next station. starting_station=i+1; curr_tank=0; } } return total_tank >= 0 && starting_station != gas.size(); } ``` 以上三个实例均体现了不同形式下的贪心思维模式及其应用技巧,它们共同之处在于总是倾向于做出当下看来最佳的动作,进而逐步构建出完整的解决方案框架。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值