求个算法，M个数，取N个排列，N>M

2021-04-30 10:37:21 2.7k 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

多机调度问题（非抢先调度） 1. 问题描述一个工程有m台一模一样的机器，我们有n个任务需要处理，任务i的处理时间为ti。所谓调度是指按任务在机器上的运行时间分配任务，使得：（1）一台机器在同一时间只能处理一个任务；（2）一个任务不能同时在两台机器上处理；（3）一个任务i的处理时间是ti个时间单位。并求出完成所有任务所需要的最短时间。2. 求解思路采用最长处理时间任务优先的贪心策略: 阅读详情

求个算法，M个数，取N个排列，N>M
比如有数字，1，2，3，取4个进行排列。
结果如下：
1 1 1 1
1 1 1 2
1 1 1 3
1 1 2 2
1 1 2 3
1 1 3 3
1 2 2 2
1 2 2 3
1 2 3 3
1 3 3 3
2 2 2 2
2 2 2 3
2 2 3 3
2 3 3 3
3 3 3 3
不可以重复，顺序可以任意。

...全文

vuecli3 实现移动端和pc端界面切换（两套代码）适合场景多页面多系统应用所有系统都在同一目录下。配置多入口多出口。每个系统之间可以链接。每个系统内依然采用Vue单页应用开发。产品需求：一套代码兼容pc端和移动端，移动端和pc端的样式布局差别很大，需要使用多界面，并判断使用手机的时候跳转移动端代码，使用pc端跳转pc端代码。项目目录分为两部分代码，pc 和mobile 第一步：创建一个登陆页面的文件在项目public文件夹下创建一个login.html，其实就是将index.html复制一份，将title改一下： <!DOCTYP 阅读详情

marmothac

C# 111,129 成员 642,539 内容

+ 关注 + 加入社区

切换为时间正序

marmothac 2021-05-05

打赏
举报

谢谢大家，不考虑效率确实很多种方法都可以。这个也确实不是排列组合，有一些特定的条件在里。我自己也写了一个，和groovy2007的python一个道量，因为取的数据量不是很大，所以倒也无妨。

yyfhz 2021-05-05

打赏
举报

本来以为是一个单纯的N进制枚举问题，加上去重后就不是了。。。
groovy2007的解答或许不是最优，但确实是对的。

引用 17 楼 groovy2007 的回复:

很简单，十几行代码的事。



def next(indexes, m, n):

    for i in range(n):

        index = indexes[i]

        # find the first one that can be increased

        if index < m-1:

            # fill 0 .. i with the increased value

            for j in range(i+1):

                indexes[j] = index+1

            return True

    return False

    

def indexToNum(index, num):

    return [num[i] for i in index]



nums = [1,2,3]

indexes = [0,0,0,0]

print(indexToNum(indexes, nums))

while next(indexes, 3, 4):

    print(indexToNum(indexes, nums))



'''Output

[1, 1, 1, 1]

[2, 1, 1, 1]

[3, 1, 1, 1]

[2, 2, 1, 1]

[3, 2, 1, 1]

[3, 3, 1, 1]

[2, 2, 2, 1]

[3, 2, 2, 1]

[3, 3, 2, 1]

[3, 3, 3, 1]

[2, 2, 2, 2]

[3, 2, 2, 2]

[3, 3, 2, 2]

[3, 3, 3, 2]

[3, 3, 3, 3]'''

qishewl 2021-05-04

打赏
举报

那我就也来试试好了，嘿嘿佩服，佩服，一篇绝世好文！

Harrison_2009 2021-05-02

打赏
举报

路过，顺便膜拜一下大神们。每天回帖即可获得10分可用分！

丁劲犇 2021-05-01

打赏
举报

https://blog.csdn.net/goldenhawking/article/details/80037669

groovy2007 2021-05-01

打赏
举报

很简单，十几行代码的事。



def next(indexes, m, n):

    for i in range(n):

        index = indexes[i]

        # find the first one that can be increased

        if index < m-1:

            # fill 0 .. i with the increased value

            for j in range(i+1):

                indexes[j] = index+1

            return True

    return False

    

def indexToNum(index, num):

    return [num[i] for i in index]



nums = [1,2,3]

indexes = [0,0,0,0]

print(indexToNum(indexes, nums))

while next(indexes, 3, 4):

    print(indexToNum(indexes, nums))



'''Output

[1, 1, 1, 1]

[2, 1, 1, 1]

[3, 1, 1, 1]

[2, 2, 1, 1]

[3, 2, 1, 1]

[3, 3, 1, 1]

[2, 2, 2, 1]

[3, 2, 2, 1]

[3, 3, 2, 1]

[3, 3, 3, 1]

[2, 2, 2, 2]

[3, 2, 2, 2]

[3, 3, 2, 2]

[3, 3, 3, 2]

[3, 3, 3, 3]'''

marmothac 2021-04-30

打赏
举报

引用 6 楼 wanghui0380 的回复:

哦，的确是个障眼法，我也迷了，不过结论正确，压根不值得考虑上面被迷，修复一下，还是M进制谁说10进制数不能表达11位数据了，所以压根不要去考虑撒N》M，这条件就是用来迷惑人的

谢谢回复。

marmothac 2021-04-30

打赏
举报

引用 3 楼飞天凤凰601 的回复:

两个循环解决的事

引用 4 楼 guanyinsishengzi 的回复:

O(n^m) 递归,n=3,m=4，得到81个数。不会递归直接写4层循环。

神仙打架，哈哈，到底几个循环

wanghui0380 2021-04-30

打赏
举报

哦，的确是个障眼法，我也迷了，不过结论正确，压根不值得考虑上面被迷，修复一下，还是M进制谁说10进制数不能表达11位数据了，所以压根不要去考虑撒N》M，这条件就是用来迷惑人的

wanghui0380 2021-04-30

打赏
举报

这样把，如果楼主还看不清，我们换个更简单直白的说法 0，1，2，3，4，5，6，7，9 取3位无非就是 000 001 002 003 ----- 009 010 ------ 999 他全排没有，重复没有至于啥N>M，其实完全就是个障眼法，根本就不值得考虑 N>M 是把？也就是用N当进制而已，不用M当进制，你该怎么进位就怎么进位，无非是最后显示的时候取个余数（模），也就是当前位的值%M

guanyinsishengzi 2021-04-30

打赏
举报

O(n^m) 递归,n=3,m=4，得到81个数。不会递归直接写4层循环。

飞天凤凰601 2021-04-30

打赏
举报

两个循环解决的事

wanghui0380 2021-04-30

打赏
举报

对啊，不想废脑筋。把你的题目换成，大家一眼就明白的，你自己就可以做 12取3，你觉着呢？？一个钟表表盘，时分秒3个指针，12小时，转一圈下来，是不是全排列了，是不是不会重复所以，自己按照钟表那么写就好，秒针转一圈，分针进1位，分针转一圈，时针进一位说白了就是N进制拉

marmothac 2021-04-30

打赏
举报

这种费脑袋的看来都不愿意想啊

xuzuning 2021-04-30

打赏
举报

P(M,N) 是从 M 个元素中取 N个做排列那么你能从 4 个数中取出 5 个数吗

morliz子轩 2021-04-30

打赏
举报

demo:


   int[] array = {1, 2, 3, 4};
            int a1, a2, a3, a4;
            int iCount = 0;
            for (int i1 = 0; i1 < array.Length; i1++)
            {
                for (int i2 = 0; i2 < array.Length; i2++)
                {
                    if (i2 == i1)
                    {
                        continue;
                    }
                    for (int i3 = 0; i3 < array.Length; i3++)
                    {
                        if (i3 == i1 || i3 == i2)
                        {
                            continue;
                        }
                        for (int i4 = 0; i4 < array.Length; i4++)
                        {
                            if (i4 == i1 || i4 == i2 || i4 == i3)
                            {
                                continue;
                            }
                            a1 = array[i1];
                            a2 = array[i2];
                            a3 = array[i3];
                            a4 = array[i4];
                            iCount++;
                            Console.WriteLine("{0}-{1}-{2}-{3}", a1, a2, a3, a4);
                        }
                    }
                }
            }
            Console.WriteLine("AllCount == {0}", iCount);
            Console.ReadKey();
        }

wanghui0380 2021-04-30

打赏
举报

引用 12 楼 marmothac 的回复:

首先谢谢啊，真是辛苦了。但对果不对啊，要求有一条是，不能重复， 1,1,1,2 和2,1,1,1是重复的。。。像你说的，只在最后一位加1，不停的向前进位即可。

额，这到底求排列啊，还是求组合？？？1,1,1,2 和2,1,1,1是重复的。也就是这2个相等，这是组合好吧我还真懒写了，你把这81个按余弦相似度做个Distinct就是结果了

marmothac 2021-04-30

打赏
举报

首先谢谢啊，真是辛苦了。但对果不对啊，要求有一条是，不能重复， 1,1,1,2 和2,1,1,1是重复的。。。像你说的，只在最后一位加1，不停的向前进位即可。

wanghui0380 2021-04-30

打赏
举报

引用 9 楼 marmothac 的回复:

[quote=引用 6 楼 wanghui0380 的回复:]哦，的确是个障眼法，我也迷了，不过结论正确，压根不值得考虑上面被迷，修复一下，还是M进制谁说10进制数不能表达11位数据了，所以压根不要去考虑撒N》M，这条件就是用来迷惑人的

M>N,还是M<N，是有点说法的，实现起来还真不是一样的[/quote] 没你想的那么复杂，你弄明白了，他就是进位随便写，反正要放假了，无心写代码，俺就随手写一个，也不讲究啥效率，性能，最优。你看看，到底所谓的N，M大小对你实现有没有啥区别，反正对于我下面的代码来说，没有任何区别

 test test = new test(3, 4);
            int[] dic = new int[] { 1, 2, 3 };

            do
            {
                Console.WriteLine(string.Join(",", test.GetCcurentIndex().Reverse().Select(p => dic[p])));

            } while (test.Increment());


     public class test
        {
            private readonly int _m;
            private readonly int _n;

            private node nodel;
            public test(int M, int N)
            {
                _m = M;
                _n = N;
                nodel = new node(M);

                node ccurentnode = nodel;
                for (int i = 0; i < _n - 1; i++)
                {
                    node tempnode = new node(M);
                    ccurentnode.parent = tempnode;
                    ccurentnode = tempnode;
                }
            }

            public bool Increment()
            {
                var lst = GetCcurentIndex();
                if (!lst.All(p => p == _m - 1))
                {
                    nodel.Increment();



                    return true;
                }
                else
                {
                    return false;
                }

            }
                public IEnumerable<int> GetCcurentIndex()
                {
                    return Show(nodel);
                }

                private IEnumerable<int> Show(node node)
                {
                    yield return node.Value;
                    if (node.parent != null)
                    {
                        var temp = Show(node.parent);
                        foreach (var item in temp)
                        {
                            yield return item;
                        }
                    }
                    else
                    {
                        yield break;
                    }

                }

           //位node
            public class node
            {
                private readonly int _n;

                public int Value { get; set; } = 0;
                public node parent { get; set; }

                public node(int N)
                {

                    _n = N;
                }

                //模拟+1，判定是否要进位
                public void Increment()
                {
                    Value = Value + 1;
                    if (Value == _n)
                    {

                        parent?.Increment();

                    }

                    Value = Value % _n;
                }
            }


        }

运行结果 1,1,1,1 1,1,1,2 1,1,1,3 1,1,2,1 1,1,2,2 1,1,2,3 1,1,3,1 1,1,3,2 1,1,3,3 1,2,1,1 1,2,1,2 1,2,1,3 1,2,2,1 1,2,2,2 1,2,2,3 1,2,3,1 1,2,3,2 1,2,3,3 1,3,1,1 1,3,1,2 1,3,1,3 1,3,2,1 1,3,2,2 1,3,2,3 1,3,3,1 1,3,3,2 1,3,3,3 2,1,1,1 2,1,1,2 2,1,1,3 2,1,2,1 2,1,2,2 2,1,2,3 2,1,3,1 2,1,3,2 2,1,3,3 2,2,1,1 2,2,1,2 2,2,1,3 2,2,2,1 2,2,2,2 2,2,2,3 2,2,3,1 2,2,3,2 2,2,3,3 2,3,1,1 2,3,1,2 2,3,1,3 2,3,2,1 2,3,2,2 2,3,2,3 2,3,3,1 2,3,3,2 2,3,3,3 3,1,1,1 3,1,1,2 3,1,1,3 3,1,2,1 3,1,2,2 3,1,2,3 3,1,3,1 3,1,3,2 3,1,3,3 3,2,1,1 3,2,1,2 3,2,1,3 3,2,2,1 3,2,2,2 3,2,2,3 3,2,3,1 3,2,3,2 3,2,3,3 3,3,1,1 3,3,1,2 3,3,1,3 3,3,2,1 3,3,2,2 3,3,2,3 3,3,3,1 3,3,3,2 3,3,3,3

xuzuning 2021-04-30

打赏
举报

对于 M个数，取N个排列，N>M N>M 是错误的条件因为条件没有满足的机会写作 M个数，取N个排列，M>N 你可以先求组合，在对组合的结果求排列求排列和组合的代码有很多，是程序员的永久话题，因为效率总是第一位的

加载更多回复（1）

求个算法，M个数，取N个排列，N>M

相关推荐