leetcode 51 N皇后& 131. 分割回文串

题目

很经典的回溯算法的题目,基本思路就是像遍历一个树一样,遍历每一种可能,但是要在一些节点进行适当的剪枝,由于我们是一行一行的进行尝试,所以对剪枝的操作只需要确保本行以上的部分情况合理就可以.

check函数

进行剪枝操作,检查如果在这个(row,col)点放置queen,与已有的queen是否冲突,要检查上面,左上,右上三个方向.

bool check(int row,int col,vector<string>& graph)
    {
        for(int k=0;k<row;k++)
        {
            if(graph[k][col]=='Q')
                return true;
        }
        for (int i = row - 1, j = col + 1;i >= 0 && j < sz; i--, j++) {
            if (graph[i][j] == 'Q')
                return true;
        }
        for (int i = row - 1, j = col - 1;i >= 0 && j >= 0; i--, j--) {
            if (graph[i][j] == 'Q')
                return true;
        }
        return  false;
    }

回溯算法

• 在第p行填充字符,graph是当前填充好的图,

1. 如果p==sz,说明[0,sz-1]行都合理,就放到答案里.
2. 如果不是sz,就是这行需要填充,在这一行的每一个位置尝试check,如果可以放queen,就把这个点置为’Q’,并且以当前的情况遍历下面的行的,这里使用递归来计算,在这个地方递归完了之后,这里是’Q’的情况都已遍历一遍,应该到右边的点,所以这个点就是’.'了.每一行就像一个树的节点,每列就好像是子节点,这很像是树的遍历剪枝

void backtrace(int p,vector<string>& graph)
    {
        if(p==sz) {ans.push_back(graph);return;}
        for(int i=0;i<sz;i++)
        {
            if(check(p,i,graph))
                continue;
            graph[p][i]='Q';
            backtrace(p+1,graph);
            graph[p][i]='.';
        }
    }

代码

class Solution {
public:
    vector<vector<string>> ans;
    int sz;
    void backtrace(int p,vector<string>& graph)
    {
        if(p==sz) {ans.push_back(graph);return;}
        for(int i=0;i<sz;i++)
        {
            if(check(p,i,graph))
                continue;
            graph[p][i]='Q';
            backtrace(p+1,graph);
            graph[p][i]='.';
        }
    }
    bool check(int row,int col,vector<string>& graph)
    {
        for(int k=0;k<row;k++)
        {
            if(graph[k][col]=='Q')
                return true;
        }
        for (int i = row - 1, j = col + 1;i >= 0 && j < sz; i--, j++) {
            if (graph[i][j] == 'Q')
                return true;
        }
        for (int i = row - 1, j = col - 1;i >= 0 && j >= 0; i--, j--) {
            if (graph[i][j] == 'Q')
                return true;
        }
        return  false;
    }
    vector<vector<string>> solveNQueens(int n) {
        sz=n;
        vector<string> tmp(n,string(n,'.'));
        backtrace(0,tmp);
        return ans;
    }
};

参考博客
(已star)

题目

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: “aab”
输出:
[
[“aa”,“b”],
[“a”,“a”,“b”]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning

分析

学习完了来一次试试.
这道题可以使用回溯算法,不断遍历下一段,实验是否能回文,能的话就在基础上实验下下一段,不能就试更长的段,基本思路和结构和上面的很像.

代码

class Solution {
public:
    vector<vector<string>> ans;
    int len;
    bool check(string& tt,int i,int j)
    {
        if(i>j) return true;
        if(tt[i]!=tt[j]) return false;
        else return check(tt,i+1,j-1);
    }
    void backtrace(string &str,int pos,vector<string>& ss)
    {
        if(pos==len){
            ans.push_back(ss);
            return;
        }
        for(int i=pos;i<len;++i)
        {            
            if(check(str,pos,i)){
                ss.push_back(str.substr(pos,i-pos+1));
                backtrace(str,i+1,ss);
                ss.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        len=s.length();
        vector<string> tmp;
        backtrace(s,0,tmp);
        return ans;
    }
};

ps:一开始我的check函数不是这么写的.是

调用

string tt=str.substr(pos,i-pos+1);
if(check(tt)){
	ss.push_back(tt);
    backtrace(str,i+1,ss);
    ss.pop_back();
}

check函数

 bool check(string& tt)
    {
        int sz=tt.length();
        for(int i=0;i<sz/2;i++)
        {
            if(tt[i]!=tt[sz-1-i]) return false;
        }
        return true;
    }

这个运行80ms,内存15.7mb

在题目的解答里看见一个和我写的几乎一样的.就是check不一样的,尽然10ms以内,内存10mb
于是改了check,看起来字符串的裁剪很费时间
这样写在字符串判断的时候没有裁剪,而是判断是回文字符串要放到vector里的时候再裁剪,节省时间,空间,妙!

事实上也有人不写check而是用dp先进行所有dp[i][j]来表示i-j是否是回文串,一开始我也是这么想的,但是感觉过于麻烦…