Question

可能重复：
Generating all Possible Combinations

我想为字符串生成所有可能的唯一模式，其中包含所有字符，包括重复字符（如果有）。

例如：

字符串：abc
模式：abc acb bca bac cab cba

字符串：abb
模式：abb bab bba

此外，是否有一个公式来说明可以为字符串创建多少个唯一模式来验证算法的有效性？到目前为止，我已经尝试了多种方法，但随着角色数量的增加，结果并不可靠。

Answer 1

您可以尝试这样的事情： -

  using System;

  namespace ConsoleApplication3
 {
    class Permute
    {
             private void swap (ref char a, ref char b)
             {
                    if(a==b)return;
                    a^=b;
                    b^=a;
                    a^=b;
              }

              public void setper(char[] list)
              {
                    int x=list.Length-1;
                    go(list,0,x);
              }

              private void go (char[] list, int k, int m)
              {
                    int i;
                    if (k == m)
                       {
                             Console.Write (list);
                             Console.WriteLine (" ");
                        }
                    else
                         for (i = k; i <= m; i++)
                        {
                               swap (ref list[k],ref list[i]);
                               go (list, k+1, m);
                               swap (ref list[k],ref list[i]);
                        }
               }
     }

     class Class1
    {
           static void Main()
           {

                  Permute p = new Permute();
                  string c="sagiv";
                   char []c2=c.ToCharArray ();
                   /*calling the permute*/
                  p.setper(c2);
              }
       }
  }

Answer 2

如果您开始对数据进行排序，则可以使用std :: next_permutation的重复调用来循环遍历所有排列。 std :: next_permutation处理重复元素的情况，比如你的abb字符串，没有问题。

Answer 3

我的想法与Rahul Tripathi相似，但我做了一件棘手的事情，让它适用于复制元素。在我们进行交换操作之前的任何时候，我们都会回过头来检查此元素之前是否已显示。如果它是一个重复元素，我们不应该进行交换操作。代码如下所示：c ++：

#include<iostream>

using namespace std;

bool isDupilicate(char input[],int start,int j)
{
     bool ret=false;
     for(int i=start;i<j;++i)
     {
             if(input[i]==input[j])
             {
                ret=true;
                break;
             }
     }
     return ret;
}

void swap(char& a,char &b)
{
     char temp=a;
     a=b;
     b=temp;
}

void permutation(char input[],int start,int length)
{
       if(start==length)
       {
           for(int i=0;i<length;++i)cout<<input[i];
           cout<<endl;
       }
       else 
       {
           for(int i=start;i<length;++i)
           {
                   if(isDupilicate(input,start,i))continue;
                   swap(input[i],input[start]);
                   permutation(input,start+1,length);
                   swap(input[i],input[start]);

           } 
       }          
}

int main()
{
    cout<<"Input for abb"<<endl;
    char input[3]={'a','b','b'};
    permutation(input,0,3);
    cout<<"________________"<<endl;

    cout<<"Input for abc"<<endl;
    input[2]='c';
    permutation(input,0,3);

    getchar();
    getchar();

}

选中此link以确定可以创建多少个独特模式！希望它有所帮助！

Answer 4

要计算唯一的排列，它只是字长（例如3）与可能字符的幂。因此，如果它是全部小写字符且单词长度为3则为3 ^ 26 = 2541865828329（26因为这是英文字母中小写字母的数量）组合。

您可以使用递归计算所有可能的组合。

为一组字符生成所有可能的模式

4 个答案: