标签：tmp nums int res c++ vector DFS leetcode board

#include <iostream>
#include <stack>
#include <vector>

using namespace std;

struct TreeNode{
    TreeNode* left = nullptr, *right = nullptr;
    int val = 0;
    TreeNode(int v):val(v){}
};

vector<int>inorder(TreeNode* root)
{
    vector<int>res;
    stack<TreeNode*>st;
    while(root != nullptr || !st.empty())
    {
        while(nullptr != root)
        {
            st.push(root);
            root = root->left;
        }
        root = st.top();
        st.pop();
        res.emplace_back(root->val);
        root = root->right;
    }
    return res;
}

void print(const vector<int>&nums)
{
    for(auto && num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
}

void dfs(vector<vector<int>>& res,const vector<int>&nums,vector<int>&tmp,int start)
{
    res.emplace_back(tmp);    
    for(int i = start; i < nums.size(); ++i)
    {        
        tmp.emplace_back(nums[i]);
        dfs(res,nums,tmp,i + 1);
        tmp.pop_back();
    }
    return ;
}

vector<vector<int>>subset(const vector<int>& nums)
{
    vector<vector<int>>res;
    vector<int>tmp;
    dfs(res,nums,tmp,0);
    return res;
}

void print(const vector<vector<int>>& nums)
{
    for(auto && num : nums)
    {
        for(auto && n : num)
        {
            cout << n << " ";
        } 
        cout << endl;
    }
    
}

bool isContain(const vector<int>& nums,int val)
{
    for(auto &num : nums)
    {
        if(num == val)return true;
    }
    return false;
}

void dfsII(const vector<int>& nums,vector<vector<int>>& res,vector<int>& tmp,int start)
{
    res.emplace_back(tmp);
    for(int i = start; i < nums.size(); ++i)
    {
        if(i != start && nums[i] == nums[i-1])continue;       
        tmp.emplace_back(nums[i]);
        dfsII(nums,res,tmp,start + 1);
        tmp.pop_back();
    }
}

vector<vector<int>>subsetII(vector<int>& nums)
{
    vector<vector<int>>res;
    vector<int>tmp;
    sort(nums.begin(),nums.end());    
    dfsII(nums,res,tmp,0);
    res.pop_back();
    return res;

}



void help(vector<int>& nums,vector<vector<int>>&res,vector<int>&tmp,int index)
{
    if(tmp.size() == nums.size())res.emplace_back(tmp);
    else
    {
    for(int i = 0; i < nums.size(); ++i)
    {
        if(isContain(tmp,nums[i]))continue;
        tmp.emplace_back(nums[i]);
        help(nums,res,tmp,index + 1);
        tmp.pop_back();
    }
    }
    
}

vector<vector<int>>permute(vector<int>& nums)
{
    vector<vector<int>>res;
    vector<int>tmp;
    sort(nums.begin(),nums.end());
    help(nums,res,tmp,0);
    return res;
}

void help(vector<int>& nums,vector<vector<int>>& res,vector<int>& tmp,int index, vector<bool>& vis)
{
    if(tmp.size() == nums.size())res.emplace_back(tmp);
    else
    {
        for(int i = 0; i < nums.size(); ++i)
        {
            if(vis[i] || i > 0 && nums[i] == nums[i-1]&& !vis[i-1])continue;
            vis[i] = true;
            tmp.emplace_back(nums[i]);
            help(nums,res,tmp,index + 1, vis);
            vis[i] = false;
            tmp.pop_back();
        }
    }
}

vector<vector<int>>permuteUnique(vector<int>& nums)
{
    vector<vector<int>>res;
    vector<int>tmp;
    sort(nums.begin(),nums.end());
    vector<bool>vis(nums.size(),false);
    help(nums,res,tmp,0,vis);
    return res;
}

void help(vector<vector<int>>& res,vector<int>&tmp,int index,int n, int k)
{
    if(tmp.size() + ( n - index + 1) < k)
    {
        return;
    }
    if(tmp.size() == k)
    {
        res.emplace_back(tmp);
        return ;        
    }
    tmp.emplace_back(index);
    help(res,tmp,index+1,n,k);
    tmp.pop_back();
    help(res,tmp,index+1,n,k);
    return ;
}


vector<vector<int>>combine(int n, int k)
{
    
    vector<vector<int>>res;
    vector<int>tmp;
    help(res,tmp,1,n,k);
    return res;
}

void print(const vector<vector<string>>&board)
{
    for(auto strs : board)
    {
        for(auto str:strs)
        {
            cout << str << " ";
        }
        cout << endl;
    }
}

bool isValid(vector<vector<string>>&board,int i, int j, char c)
{
    for(int row = 0; row < 9; ++row)
    {
        if(board[row][j][0] == c)return false;
    }

    for(int col = 0; col < 9; ++col)
    {
        if(board[i][col][0] == c)return false;
    }
    int rowIndex = (i / 3) * 3,colIndex = (j / 3) * 3;
    for(int m = rowIndex; m < rowIndex + 3; ++m)
    {
        for(int n = colIndex; n < colIndex + 3; ++n)
        {
            if(board[m][n][0]==c)return false;
        }
    }
    return true;
}

bool solve(vector<vector<string>>&board)
{
    int m = board.size(),n = board[0].size();
    for(int i = 0; i < m; ++i)
    {
        for(int j = 0;j < n; ++j)
        {
            if(board[i][j] == ".")
            {
                for(char c = '1'; c <= '9'; ++c)
                {                    
                    if(isValid(board,i,j,c))
                    {                        
                        board[i][j][0] = c;                        
                        if(solve(board))return true;
                        else board[i][j] = ".";
                    }                    
                }
                return false;                
            }
        }
    }
    return true;
}

vector<vector<string>> solveSudoku(vector<vector<string>>& board) {
    solve(board);
    return board;
}

vector<string>construct(vector<vector<char>>&board)
{
    vector<string>res;
    for(int i = 0; i < board.size(); ++i)
    {
        string s = "";
        for(int j = 0; j < board[i].size(); ++j)
        s.push_back(board[i][j]);        
        res.emplace_back(s);
    }    
    return res;
}

bool valid(vector<vector<char>>&board,int x,int y)
{
    for(int i = 0; i < board.size(); ++i)
    {
        for(int j = 0; j < y; ++j)
        {                  
            if(board[i][j] == 'Q' &&((x+j) == (y + i) || (x == i) || (x + y) == (i + j)))
            return false;
        }
        
    }
    return true;
}

void dfs(vector<vector<char>>&board,int colIndex,vector<vector<string>>& res)
{   
    if(colIndex == board.size())
    {
        
        res.emplace_back(construct(board));
        return;
    }
    for(int i = 0; i < board.size(); ++i)
    {
        if(valid(board,i,colIndex))
        {
            board[i][colIndex] = 'Q';
            dfs(board,colIndex + 1,res);
            board[i][colIndex] = '.';
        }
    }
}

vector<vector<string>>Nqueens(int n)
{
    vector<vector<char>>board(n,vector<char>(n,'.'));
    vector<vector<string>>res;
    dfs(board,0,res);
    return res;
}

int main()
{
    //LeetCode94
    TreeNode n0(1);
    TreeNode n1(2);
    TreeNode n2(3);
    n0.right = &n1;
    n1.left = &n2;
    print(inorder(&n0));

    //LeetCode78
    vector<int>nums{1,2,3};    
    print(subset(nums));

    //LeetCode90
    nums = {1,2,2};
    print(subsetII(nums));

    // LeetCode46
    nums = {1,2,3};
    print(permute(nums));

    //LeetCode47
    cout << "======" << endl;
    nums = {1,1,2};
    print(permuteUnique(nums));

    //LeetCode77
    cout << "======" << endl;
    int n = 4, k = 2;
    print(combine(n,k));

    //LeetCode37
    cout << "======" << endl;
    vector<vector<string>>grid=
    {{"5","3",".",".","7",".",".",".","."},
    {"6",".",".","1","9","5",".",".","."},
    {".","9","8",".",".",".",".","6","."},
    {"8",".",".",".","6",".",".",".","3"},
    {"4",".",".","8",".","3",".",".","1"},
    {"7",".",".",".","2",".",".",".","6"},
    {".","6",".",".",".",".","2","8","."},
    {".",".",".","4","1","9",".",".","5"},
    {".",".",".",".","8",".",".","7","9"}};    
    print(solveSudoku(grid));

    //LeetCode51
    n = 4;    
    print(Nqueens(n));

    
    return 0;
}

标签：tmp,nums,int,res,c++,vector,DFS,leetcode,board
来源： https://www.cnblogs.com/fourmi/p/16247832.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。