LeetCode-Word Break II -断词-DP优化

https://oj.leetcode.com/problems/word-break-ii/

首先这个问题显然是可以利用以前搜索的结果，所以可以看出是一个具有DP性质的递推关系的题目。

f(int p):后n-p个单词已经被断句的条件下，前p个所有组成的断句结果都有哪些，我们还需要一个数组dpf[]，来保存前p个字符能不能被断句用以判断。

如果按着这个思路直接DP会超时，超时原因主要有两个：

1）对每个位置，可能dp[p]需要存储大量的字符串，而每个字符串都是s的一部分，其实可以用s的一系列索引来代替。

2）我们其实只需要dp[n]的所有结果，而这个结果中路径的存在建立在前面的子问题dp[j]都合法存在的情况下。所以其实可以先计算出dp[p]是否能被断句，不能的话就没必要构造dp[p]了。

这样两个优化能够过了所有CASE。

const int MAX_N=1000;
class Solution {
public:
	int m,n;
	vector <vector<int>>	dp[MAX_N];
	bool					dpf[MAX_N];
	void ConCat(vector<vector<int>> &res,vector <vector<int>> &prevs,int cur){
		for (int i=0;i<prevs.size();i++){
			vector<int> temp=prevs[i];
			temp.push_back(cur);
			res.push_back(temp);
		}
	}
	vector<string> wordBreak(string s, unordered_set<string> &dict) {
		memset(dpf,0,sizeof(dpf));
		n=s.length();
		dpf[0]=true;
		for(int i=1;i<=n;i++){          //dp figure out whether sequence before one pos can be break
			for (int j=0;j<i;j++){
				string cur=s.substr(j,i-j);
				if (dict.find(cur)!=dict.end()){
					dpf[i]|=dpf[j];
				}
			}
		}
		vector <string> res;
		if (!dpf[n]){
			return res;
		}
		dp[0].push_back(vector<int>(1,0));
		for(int i=1;i<=n;i++){
			if (!dpf[i]){continue;}
			for (int j=0;j<i;j++){
				if (!dpf[j]){continue;}
				string cur=s.substr(j,i-j);
				if (dict.find(cur)!=dict.end()){//we only concat the 'can break' sequences
					ConCat(dp[i],dp[j],i);
				}
			}
		}
		res.resize(dp[n].size(),"");
		for (int i=0;i<dp[n].size();i++){
			for (int j=0;j<dp[n][i].size()-1;j++){
				string temp=s.substr(dp[n][i][j],dp[n][i][j+1]-dp[n][i][j]);
				if (j>0){res[i]+=" ";}
				res[i]+=temp;
			}
		}
		return res;
	}
};