排列组合问题

2013-06-06 09:13:44 302 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

aaaabbbccd9876 墨衍会员 · AI 创作全网分发关注 + 加入社区

怒刷排列组合，如何解“排列组合”一类的问题怒刷排列组合在刷Leetcode题目时，时常会看到一些大佬提出时间复杂度为O(1)的题解，而我还在O(nm)和O(n)之间如此反复，细细品味，其实有一类题目是经常可以爆出O(1)的解法的，这一类题目背后的数学依据就是排列组合。顾名思义，排列即排列，组合即组合，排列组合主要是用来解决做一件事情有多少种方法或者某件事发生的概率是多少的问题。例如小明从家到学校可以选择步行、骑车、坐出租车。**问题1：**小明从家到学校有几种出行方式？**问题2：**小明从家到学校再返回家中，有几种出行方式？针对上述的两个问阅读详情

先举个例子，如abc的组合有a,b,c,,ab,ac,bc,ba,ca,cb,abc,acb,bac,bca,cab,cba.列出所有可能的组合,求实现该功能算法，abc只是个例,是传的一个参数

...全文

告别“盲开”：手把手教你用MCU内置比较器搞定BLDC无感方波启动（附代码片段）本文详细介绍了如何利用MCU内置比较器实现BLDC无感方波启动，解决传统无传感器控制中的'盲开'问题。通过虚拟中性点电路设计和三段式启动流程，结合反电动势检测和过零检测技术，提供了一套经济高效的解决方案，并附有可直接移植的代码片段，助力工程师快速实现可靠的无感控制。阅读详情

aaaabbbccd9876

Java SE 62,620 成员 307,251 内容

+ 关注 + 加入社区

切换为时间正序

aaaabbbccd9876 2013-06-07

打赏
举报

分不多，请大神们见谅，很感谢你们的帮助

aaaabbbccd9876 2013-06-07

打赏
举报

两位大神果然牛，结贴给分

kosora曹 2013-06-06

打赏
举报

4楼提供的递归算法很好，利用空间树的层次遍历思想，还可以得到非递归算法：



import java.util.LinkedList;
import java.util.Queue;

import org.junit.Test;

/**
 * 幂集的节点
 *
 */
class MijiNode{
	
	/**
	 * 数据
	 */
	private String data;
	
	/**
	 * 层
	 */
	private int ceng;
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}
	public int getCeng() {
		return ceng;
	}
	public void setCeng(int ceng) {
		this.ceng = ceng;
	}
	public MijiNode(String data, int ceng) {
		super();
		this.data = data;
		this.ceng = ceng;
	}
	public MijiNode() {
		super();
	}
	@Override
	public String toString() {
		return "MijiNode [data=" + data + ", ceng=" + ceng + "]";
	}
}

/**
 * 全排列节点
 *
 */
class AllSortNode{
	
	/**
	 * 左子串
	 */
	private String leftStr;
	
	/**
	 * 右子串
	 */
	private String rightStr;
	public String getLeftStr() {
		return leftStr;
	}
	public void setLeftStr(String leftStr) {
		this.leftStr = leftStr;
	}
	public String getRightStr() {
		return rightStr;
	}
	public void setRightStr(String rightStr) {
		this.rightStr = rightStr;
	}
	public AllSortNode(String leftStr, String rightStr) {
		super();
		this.leftStr = leftStr;
		this.rightStr = rightStr;
	}
	public AllSortNode() {
		super();
	}
	@Override
	public String toString() {
		return "AllSortNode [leftStr=" + leftStr + ", rightStr=" + rightStr
				+ "]";
	}
	
}

public class MijiAndAllSort {
	/**
	 *求幂集
	 */
public Queue<MijiNode> createMiji(String str){
	Queue<MijiNode> que=new LinkedList<MijiNode>();
	MijiNode root=new MijiNode("", 0);
	que.offer(root);
	while(que.size()<Math.pow(2, str.length())){
		MijiNode p=que.poll();
		MijiNode leftCh=new MijiNode(p.getData()+str.charAt(p.getCeng()), p.getCeng()+1);
		MijiNode rightCh=new MijiNode(p.getData(), p.getCeng()+1);
		que.offer(leftCh);
		que.offer(rightCh);
	}
	for(MijiNode node:que){
		String s=node.getData();
		StringBuffer sb=new StringBuffer();
		int i=0;
		for(;i<s.length();i++){
			sb.append(s.charAt(i));
		}

		node.setData(sb.toString());
	}
	return que;
}

/**
 * 求全排列
 */
public void allSort(String s){
	Queue<AllSortNode> que=new LinkedList<AllSortNode>();
	String leftRoot="";
	String rightRoot=s;
	AllSortNode root=new AllSortNode(leftRoot, rightRoot);
	que.offer(root);
	while(true){
		if(que.peek().getRightStr().length()==0){
			break;
		}else{
			AllSortNode currentRoot=que.poll();
			String rightStr=currentRoot.getRightStr();
			String leftStr=currentRoot.getLeftStr();
			int len=rightStr.length();
			for(int i=0;i<len;i++){
				StringBuffer sb=new StringBuffer(rightStr);
	        	sb.deleteCharAt(i);
	        	String leftChStr=leftStr+" "+rightStr.charAt(i);
	        	String rightChStr=sb.toString();
                AllSortNode node=new AllSortNode(leftChStr, rightChStr);
                que.offer(node);
			}
		}
	}
	while(!que.isEmpty()){
		System.out.println(que.poll().getLeftStr());
	}
}
@Test
public void testMijiAndAllSort(){
	Queue<MijiNode> que=this.createMiji("abc");
	String s=null;
	for(MijiNode node:que){
		s=node.getData();
		if(s!=null){
			this.allSort(s);
		}
				}
}
}

结果： a b c a c b b a c b c a c a b c b a a b b a a c c a a b c c b b c

Inhibitory 2013-06-06

打赏
举报

import java.util.LinkedList;
import java.util.List;

public class Hello {
    /**
     * 先求组合，对每个组合求排列.
     */
    private static List<Character> combinationResult = new LinkedList<Character>();

    public static void combination(Character[] chs, int index) {
        for (int i = index; i < chs.length; ++i) {
            combinationResult.add(chs[i]);

            permutation(combinationResult.toArray(new Character[0]), 0);

            combination(chs, i + 1);

            combinationResult.remove(combinationResult.size() - 1);
        }
    }

    /**
     * 求排列.
     */
    private static List<Character> permutationResult = new LinkedList<Character>();

    public static void permutation(Character[] chs, int index) {
        for (int i = 0; index < chs.length && i < chs.length; ++i) {
            if (permutationResult.contains(chs[i])) {
                continue;
            }

            permutationResult.add(chs[i]);

            if (permutationResult.size() == chs.length) {
                System.out.println(permutationResult);
            }

            permutation(chs, index + 1);

            permutationResult.remove(permutationResult.size() - 1);
        }
    }

    public static void main(String[] args) {
        String str = "abc";
        List<Character> chs = new LinkedList<Character>();
        for (char c : str.toCharArray()) {
            chs.add(c);
        }

        combination(chs.toArray(new Character[0]), 0);
    }
}

[a]
[a, b]
[b, a]
[a, b, c]
[a, c, b]
[b, a, c]
[b, c, a]
[c, a, b]
[c, b, a]
[a, c]
[c, a]
[b]
[b, c]
[c, b]
[c]

地下室森林 2013-06-06

打赏
举报

先按照个数分组，再对每组进行排列

Inhibitory 2013-06-06

打赏
举报

1. 先求组合 2. 对每一个组合求排列

摆烂办不到 2013-06-06

打赏
举报

问题有点复杂等大神来解

排列组合问题

相关推荐