possible sentences蘑菇街2019年春招后端岗位的算法编程题解题思路与代码

先来看下题目要求吧：

• 空间限制：32768K
• 时间限制：1秒

Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.
Return all such possible sentences.

 

输入描述:

s ="catsanddog"
dict ="cat", "cats", "and", "sand", "dog"

输出描述:

[cats and dog, cat sand dog]

示例1

输入

s ="catsanddog"
dict ="cat","cats","and","sand","dog"

输出

[cats and dog, cat sand dog]

看这个示例相信大家大概能够明白题目意思了，就是给定一个字典dict，在s中找到匹配字典dict中单词的所有可能的句子sentence，然后按照一定的格式去输出这些句子sentence。这里有个特殊的测试用例，那就是

输入：

s ="chinadailybook"

dict ="in","china","book","daily"

输出：

[china daily book]

为什么说这个测试用例有点特殊呢，因为这个测试用例输入的dict中 book在daily前面，而输出结果中是daily在book前面，这样就提示了我们，输出的结果是要按原本s的结构来输出的，毕竟是输出句子sentence嘛，肯定是china daily book 而不是china book daily。

这个问题说明清楚之后，我们就来探讨下题目的解法：

首先我们不谈回溯法，就从人最基本的思路开始，我们可能首先会想到将dict中的单词剥离出来之后去一个一个的匹配，这是我们通常都能想到的，那么这里涉及到什么呢，比如说我们拿到cats这个单词，我们就要考虑应不应该去匹配catsanddog，为什么这样说呢，因为我们可以发现cats使用不使用是不同的结果，所以我们应该对每个字典当中的的单词都进行一次判断，所以这里总共就有2*2*2...*2种可能性，这里有多个少个2根据字典dict中单词的个数决定，谈到这里你可能会觉得这不所有情况都列出来了吗，不是穷举法了吗。我们先保持着这样一个疑问，先来用图表示这个可能性吧：

根据图中的信息，相信大家应该明白不少，显然这是一个回溯法，为什么叫回溯法呢，因为当我们遍历完一个sand的左子树时，应将进入左子树时修改的信息还原，不至于影响右子树的遍历，这还原就是以个回溯的过程，下面就提供我自己AC的代码：

import java.util.*;
import java.util.Scanner;

public class Main {
	private static String s;
	private static String d[];
	private static List<int[]>resultList;
	public static void fun(int i,int[] check,String current) {
		if(current.length()==0) {
			int checkd[]=new int[check.length];
			for(int j=0;j<check.length;j++) {
				checkd[j]=check[j];
			}
			resultList.add(checkd);
			return;
		}
		if(i>=d.length) {
			return;
		}
		//判断是否需要进入左子树
		int sumLength=0;
		//求出剩余子集中字符串的长度
		for(int j=i+1;j<d.length;j++) {
			sumLength+=d[j].length();
		}
		if(current.length()<=sumLength) {
			//可以进入左子树
			int cTemp=check[i];
			check[i]=0;
			fun(i+1,check,current);
			//回溯
			check[i]=cTemp;
		}
		
		//判断是否可以进入右子树
		if(current.indexOf(d[i])!=-1) {
			String cuTemp=current;
			current=current.substring(0,current.indexOf(d[i]))+current.substring(current.indexOf(d[i])+d[i].length());
			int cTemp=check[i];
			check[i]=1;
			fun(i+1,check,current);
			//回溯
			check[i]=cTemp;
			current=cuTemp;
		}
	}

	public static void main(String args[]) {
		Scanner scan=new Scanner(System.in);
		s=scan.nextLine();
		s=s.substring(s.indexOf("\"")+1, s.lastIndexOf("\""));
		String dict=scan.nextLine();
		dict=dict.substring(dict.indexOf("=")+1);
		d=dict.split(",");
		for(int i=0;i<d.length;i++) {
			d[i]=d[i].substring(d[i].indexOf("\"")+1, d[i].lastIndexOf("\""));
		}
		int []check=new int[d.length];
		for(int i=0;i<check.length;i++) {
			check[i]=-1;
		}
		String current=s;
		resultList=new ArrayList<int[]>();
		fun(0,check,current);
		
		System.out.print("[");
		//将对结果集中的结果进行处理
		Iterator iter=resultList.iterator();
		int size=resultList.size();
		int count=0;
		while(iter.hasNext()) {
			
			String sTemp=new String(s);
			int []p=(int [])iter.next();
			for(int i=0;i<p.length;i++) {
				if(p[i]==1) {
					int index=sTemp.indexOf(d[i])+d[i].length();
					if(index!=sTemp.length()) {
						String sTemp1=sTemp.substring(0,index);
						String sTemp2=sTemp.substring(index);
						sTemp=sTemp1+" "+sTemp2;
					}
				}
			}
			System.out.print(sTemp);
			if(count<size-1) {
				System.out.print(", ");
				count++;
			}
		}
		System.out.print("]");	
	}
}