# leetcode-Palindrome Partitioning II

### Palindrome Partitioning II

Total Accepted: 11791 Total Submissions: 66110

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

For example, given s = `"aab"`,
Return `1` since the palindrome partitioning `["aa","b"]` could be produced using 1 cut.

Have you been asked this question in an interview?

```class Solution {
public:
int minCut(string s) {
ans = INT_MAX;
findMinCut(s, 0, 0);
return ans;
}
private:
int ans;

void findMinCut(const string &s, int k, int currCut) {
string substr;
for (int i=k; i<s.size(); ++i) {
if (isPalindrome(s, k, i)) {
if (i+1 == s.size()) {
if (currCut+1 < ans) {
ans = currCut+1;
}
} else {
findMinCut(s, i+1, currCut+1);
}
}
}
}

bool isPalindrome(const string &s, int b, int e) {
int i=b, j=e;
while (i<j) {
if (s[i] != s[j])
return false;
++i;
--j;
}
return true;
}
};```

```class Solution {
public:
int minCut(string s) {
minCutNum = INT_MAX;
vector<string> paths;
find(s, 0, paths);
return minCutNum;
}
private:
int minCutNum;
map<int, int> minCutsMap;
void find(const string& s, int ind, vector<string>& paths)
{
for (int i = ind; i < s.size(); ++i) {
if (isPalindrome(s, ind, i)) {
if (paths.size() > minCutNum)
continue;
if (minCutsMap.find(i+1) != minCutsMap.end()) {
if (paths.size() + minCutsMap.size() - 1 < minCutNum) {
minCutNum = paths.size() + minCutsMap.size() - 1;
}
continue;
}
paths.push_back(s.substr(ind, i - ind + 1));
if (i + 1 == s.size()) {
if (minCutNum > paths.size() - 1) {
minCutNum = paths.size() - 1;
}
paths.pop_back();
continue;
}
int num = paths.size();
minCutsMap[i + 1] = INT_MAX;
find(s, i + 1, paths);
if (minCutsMap[i + 1] > paths.size() - num) {
minCutsMap[i + 1] = paths.size() - num;
}
if (minCutNum == 0)
return;
paths.pop_back();
}
}
}
bool isPalindrome(const string& str, int begin, int end)
{
while (begin < end) {
if (str[begin] != str[end])
return false;
++begin; --end;
}
return true;
}
};```

```class Solution {
public:
int minCut(string s) {
int len = s.size();
bool **isPalindrome = new bool*[len];
for (int i = 0; i < len; ++i) {
isPalindrome[i] = new bool[len];
}
initIsPalindrome(isPalindrome, s);

int *dp = new int[len]; // dp[i] stores minimum cuts for s[i]...s[len-1]
for (int i = len - 1; i >= 0; --i) {
if (isPalindrome[i][len - 1]) {
dp[i] = 0;
continue;
}
dp[i] = INT_MAX;
for (int j = i + 1; j < len; ++j) {
if (isPalindrome[i][j - 1]) {
if (dp[j] + 1 < dp[i]) {
dp[i] = dp[j] + 1;
}
}
}
}
int ret = dp[0];
for (int i = 0; i < len; ++i)
delete []isPalindrome[i];
delete []isPalindrome;
delete dp;
return ret;
}
private:
void initIsPalindrome(bool ** isPalindrome, const string& s) {
int len = s.length();
for (int L = 1; L <= len; ++L) { // L is the length of substring, from 1 to len
for (int i = 0; i < len - L + 1; ++i) { // i is the starting index
int j = i + L - 1; // j is the ending index
if (L == 1) {
isPalindrome[i][j] = true;
} else if (L == 2) {
isPalindrome[i][j] = s[i] == s[j];
} else {
isPalindrome[i][j] = (s[i] == s[j]) && isPalindrome[i + 1][j - 1];
}
}
}
}
};
```

leetcode-Palindrome Partitioning II,布布扣,bubuko.com

leetcode-Palindrome Partitioning II

(0)
(0)

0条