相关疑难解决方法(0)

在Python中,我有一个列表:

L = [1, 2, 45, 55, 5, 4, 4, 4, 4, 4, 4, 5456, 56, 6, 7, 67]  

我想确定发生次数最多的项目.我能够解决它,但我需要最快的方法来解决它.我知道有一个很好的Pythonic答案.

设A是一个大小的数组N.(i,j)如果i < j和,我们将几个索引称为"反向"A[i] > A[j]

我需要找到一个接收大小数组N(带有唯一数字)的算法,并返回时间的倒数O(n*log(n)).

可能重复:
计算数组中的反转

这是一个电话采访问题:"查找数组中的反转次数".我猜他们的意思是O(N log N)解决方案.我认为它不能比O(N log N)更好,因为这是排序的复杂性.

类似问题的答案可归纳如下:

1. 计算元素移动距离的一半以对数组进行排序:复制数组并对副本进行排序.对于原始数组的每个元素,a[i]找到它j在排序副本(二进制搜索)中的位置,并将距离的一半加起来abs(i - j)/2.

2. 修改merge sort:修改merge以计算两个已排序数组之间的反转,并merge sort使用修改后的数组运行merge.

   是否有意义 ？还有其他(可能更简单)的解决方案吗？电话采访难道不是很难吗？

给定 (1, 2, 3,..N) 的两个排列，

Consider for n = 5

5 4 3 2 1  
3 2 4 1 5  

在两个排列中找到使 index(a)<index(b) 的对 (a,b) 的数量？
在上述情况下，答案是 4。

(4,1) index(4)<index(1) in both permutations.
(3,1) 
(2,1)
(3,2)

我们可以在 O(n ² ) 中轻松完成此操作，但我觉得我们可以在 O(nlogn) 中完成此操作。你能帮忙吗？

另一个例子...

for n = 5

3 4 1 5 2 
1 3 2 5 4

这里的答案是 5

(3,4) index(3)<index(4) in both perms.
(3,5) index(3)<index(5) in both perms.
(3,2)
(1,5)
(1,2)  

我接受了这个采访:

如果对于i <j,则N [i]> N [j],数字被称为"反向排序".例如,在列表中:3 4 1 6 7 3,反向排序的项目是(3,1)(4,1)(4,3)(6,3)(7,3).

如何在O(nlogn)时间内获得反向排序项的对数.

我们有一个未分类的N个数字序列(1,2,3,4,... N).我们可以通过按特定顺序交换相邻元素来对整个序列进行排序.给定序列,如何计算对序列进行排序所需的最小可能交换.

例如,考虑序列{4,2,5,3,1}.

对此进行排序的最佳方法是按以下顺序使用7次交换

1. 交换3,1:{4,2,5,1,3}
2. 交换5,1:{4,2,1,5,3}
3. 交换4,2:{2,4,1,5,3}
4. 交换4,1:{2,1,4,5,3}
5. 交换2,1:{1,2,4,5,3}
6. 交换5,3:{1,2,4,3,5}
7. 交换3,4:{1,2,3,4,5}

一个贪婪的算法并没有证明是富有成效的.一个反例很容易构建.接近解决方案的下一个明显选择是动态编程.

假设我们有一个未排序的序列:{A1,A2,... Ai,A(i + 1),...,An}.我们知道对序列{Ai,A(i + 1),...,An}进行排序所需的最小交换次数是Min [Ai,A(i + 1),...,An}.问题是找到Min [A(i-1),Ai,...,An].

好吧,我想到的第一个想法就是添加将A(i-1)放在已经排序的序列{Ai,...,An}中的正确位置所需的步骤数.这是有效的:问题中给出的例子已经使用完全相同的方法解决了.

但我无法证明这个解决方案的有效性.这种情况经常发生在我身上.当我认为我已经解决了问题时,我能做的最好的就是获得一个"直观"的证据.我在高中并且没有正确的算法训练.我纯粹出于兴趣而这样做.

是否有严格的数学符号表明这个问题可以转化为正式的证明？这种符号可以扩展到其他问题吗？怎么样？如果能够以高中生可以理解的形式呈现,我将不胜感激.

数组中的反转是一对索引(i,j),使得a [i]> a [j]和i <j.

给定2个阵列A和B,我们必须返回这样的对的数量,使得a [i]> b [j]和i <j.

示例:

设n = 3,A [] = [5,6,7],B [] = [1,2,3]则答案为3. 3对为(5,2),(5,3)和(6 ,3).

我的代码:

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int len;
    scanf("%d",&len);
    int a[len];
    int b[len];
    for(int i = 0; i < len; i++)
       scanf("%d",&a[i]);
    for(int i = 0; i < len; i++)
       scanf("%d",&b[i]);
    int count = 0;
    for (int i = 0;i < len; i++)
    {
        for(int j = i+1; j < len; j++)
        {
             if(a[i] > b[j]) …

如果以随机顺序给出数组,则必须输出转换为循环排序数组所需的最小交换数.

例如,给出的阵列是3 5 4 2 1

所以第一次交换将是5 < - > 4结果:3 4 5 2 1秒交换将是2 < - > 1结果:3 4 5 1 2(最终)

输出:2

我无法理解这个问题背后的逻辑.

添加更多: 只能在相邻元素之间进行交换,数字在1到N之间

我想计算两个不同长度的列表之间的相似性.

例如:

listA = ['apple', 'orange', 'apple', 'apple', 'banana', 'orange'] # (length = 6)
listB = ['apple', 'orange', 'grapefruit', 'apple'] # (length = 4)

如您所见,单个项目可以在列表中多次出现,并且长度大小不同.

我已经考虑过比较每个项目的频率,但这并不包含每个列表的大小(一个列表只是另一个列表的两倍应该是相似的,但不完全相似)

EG2:

listA = ['apple', 'apple', 'orange', 'orange']
listB = ['apple', 'orange']
similarity(listA, listB) # should NOT equal 1

所以我基本上想要包含列表的大小以及列表中项目的分布.

有任何想法吗？

我有兴趣实现14-15拼图:

我正在按递增的顺序创建一个值为0到15的数组:

S = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}

现在,我想要做的就是改变它们以创建一个新的拼图实例.但是,我知道如果我创建一个具有"奇数排列"而不是无法解决的板.

维基百科说我需要创建一个具有均匀排列的拼图.我相信这意味着我只需要确保我进行偶数交换？

我将如何修改Fisher-Yates,以确保我最终得到一个均匀的排列？如果我对数组中的每个元素进行交换,这将是16个交换,我相信这将是一个偶数排列.但是,我是否需要关注自己交换？有没有其他方法可以确保我有一个有效的拼图？