刷题算法模板

算法模板

记录再此可以多看看.

判断是否是x的幂次方

class Solution {
public:
    bool 函数名(int n) {
	if (n == 0)
		return false;
	if (n == 1)
		return true;

    //如果余x不能与0,那么一定不是x的幂
	return n % x == 0 ? 函数名(n / x) : false;
    }
};

滑动窗口:

int windows[128] = { 0 };
int left = 0,right = 0;
while(right<s.length){
	++windows[s[right]];		//扩展
	right++;
    
    //第二次循环,达到限制值,开始缩减
	while(条件){
        
        //判断是否满足结果
		if(){}	
        
        //缩减
		--windows[s[left]];	
		left++;
	}
}

层序遍历模板(迭代):

vector<vector<int>> levelOrder(TreeNode* root) 
{
    //迭代需要用辅助队列
	queue<TreeNode *> que;		
    
    //头节点先压入队列
	que.push(root);
    
    //用来存储队列头节点
	TreeNode *node;			
	while (!que.empty())
	{
		node = que.front();
		que.pop();			//出队
		if (node->left)		//左孩子
		{
            que.push(node->left);
            ...
		}
		if (node->right)	//右孩子
		{
            que.push(node->right);
            ...
		}
	}
	return ;
}

树DFS模板(深度优先):

void dfs(TreeNode*root, vector<int> path)
{
    //空节点直接返回即可
	if (!root) 
		return;  
    
    //逐值添加进容器
	path.push_back(root->val); 
    
    //到了叶子节点,确定返回条件
	if (!root->left && !root->right) 
	{
		'''
		return;
	}
    //递归建立
	dfs(root->left, path,res);  
	dfs(root->right, path,res);
}

回溯模板

//用来存储结果
vector<vector<int>> res;
//递归加回溯算法,一般都是void类型.path用来记录路径,start记录当前开始的下标
//我比较喜欢path作为参数,这样path就相当于自然回溯了.不需要在path.pop_back();
//for找层序.递归找深度.
void backTracking(vector<int>path,int start,...)
{
    //先加入路径
   	path.push_back( );
    //递归终止条件
    if(判断条件)
    {
        res.push_back(path);
        return;
	}
    //num需要根据题意判断
    for(int i = start + 1; i < num; i++)
    {
		backTracking(path,i,...)
    }
}

图BFS模板:

图有多个源点,需要标记,还需要用到一个队列来存储源点.

//定义4个方向
static vector<vector<int>> dirs[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };
//如果在leetocde刷需要换成://
//private:
    //static constexpr int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
 

类型 BFS(vector<vector<int>>& matrix)
{
    int m = matrix.size(), n = matrix[0].size();
    
    //标记
    vector<vector<int>> flag(m, vector<int>(n));
    
    //队列来存储源点
    queue<pair<int, int>> que;
    
    //满足条件的源点入列,打上标记
	for (int i = 0; i < m; ++i) 
    {
    	for (int j = 0; j < n; ++j) 
    	{
    		//条件
        	if (---)
        	{
            	que.emplace(i, j);
            	flag[i][j] = 1;
        	}
    	}
    }
    
   while (!que.empty()) 
   {
       //获取源点
       int i = que.front().first;
       int j = que.front().second;
       que.pop();  
       
       for (int d = 0; d < 4; d++)
       {
         //源点的周围点
         int ni = i + dirs[d][0];
         int nj = j + dirs[d][1];
         //如果没用越界且该点没有被标记
         if (ni >= 0 && ni < m && nj >= 0 && nj < n && !flag[ni][nj])
         {
             //处理
             ...
             //处理完要把该点当成源点
             que.emplace(ni, nj);
             //打上标记
             flag[ni][nj] = 1;
         }
       }
   }
    
   return;
}

后面会持续更新