int minCut(string s) {
int n = (int) s.length();
vector<vector<int> > nexts(n+1);
for (int i = 0; i < n; i++){
for (int d = 0; (i-d >= 0 && i+d < n); d++){
if (s[i-d] == s[i+d]) {
nexts[i-d].push_back(i+d+1);
}
else break;
}
for (int d = 0; (i-d >= 0 && i+d < n); d++){
if (s[i-d] == s[i+1+d]) {
nexts[i-d].push_back(i+d+2);
}
else break;
}
}
// This version is a quadratic algorithm, subject to reduce to O(1)
vector<int> nPath(n+1, INT_MAX);
nPath[0] = 0;
for (int i = 0; i < n; i++){
for (int j = 0; j < nexts[i].size(); j++){
nPath[nexts[i][j]] = min(nPath[nexts[i][j]], nPath[i] + 1);
}
}
return nPath[n] - 1;
}
string countAndSay(int n) {
if (n == 0) return "";
string s("1");
for (int i = 1; i < n; i++) {
s = nexts(s);
}
return s;
}
vector<vector<string> > partition(string s) {
int n = (int) s.length();
vector<vector<int> > nexts(n+1);
for (int i = 0; i < n; i++){
for (int d = 0; (i-d >= 0 && i+d < n); d++){
if (s[i-d] == s[i+d]) {
nexts[i-d].push_back(i+d+1);
}
else break;
}
for (int d = 0; (i-d >= 0 && i+d < n); d++){
if (s[i-d] == s[i+1+d]) {
nexts[i-d].push_back(i+d+2);
}
else break;
}
}
vector<vector<vector<int> > > pSoFar(n+1);
pSoFar[0] = {{0}};
for (int i = 0; i < n; i++){
for (int j = 0; j < nexts[i].size(); j++){
for (int k = 0; k < pSoFar[i].size(); k++){
vector<int> vpass = pSoFar[i][k];
vpass.push_back(nexts[i][j]);
pSoFar[nexts[i][j]].push_back(vpass);
}
}
}
int nr = pSoFar[n].size();
vector<vector<string> > result(nr);
for (int i = 0; i < pSoFar[n].size(); i++){
for (int j = 0; j < pSoFar[n][i].size()-1; j++){
int a = pSoFar[n][i][j];
int b = pSoFar[n][i][j+1];
result[i].push_back(s.substr(a, b - a));
}
}
return result;
}
int nthSuperUglyNumber(int n, vector<int>& primes) {
const int m = primes.size();
vector<int> v(n);
vector<int> indexs(m, 0);
vector<int> nexts(m);
v[0] = 1;
for (int i = 1; i < n; i++) {
int min_next = INT_MAX;
for (int j = 0; j < m; j++) {
nexts[j] = v[indexs[j]] * primes[j];
min_next = min(min_next, nexts[j]);
}
for (int j = 0; j < m; j++) {
if (min_next == nexts[j]) {
indexs[j]++;
}
}
v[i] = min_next;
}
return v[n-1];
}
