做题模板小结

深度搜索

#include <iostream>
#include <vector>
using namespace std;
int n=3,m=3;//搜索地域的大小(一般题目）会给出
vector< vector<char> > map(n,vector<char>(m));//搜索的地方
vector< vector<bool> > visi(n,vector<bool>(m));//搜索的标记
int dir[4][2]{{-1,0},{0,-1},{1,0},{0,1}};//搜索的方向（由题目而定）


bool in(int x,int y)
{
    return 0<=x&&x<n&&0<=y&&y<m;
}

void DFS(int x,int y)//x,y为搜起点坐标
{
    //搜索结束判定
     if (map[x][y]=='T')
     {
        return;
     }
     visi[x][y]=true;//已搜索的标记

      for (int i=0;i<4;i++ )//搜索给定方向的位置
      {
         int dx=x+dir[i][0];
         int dy=y+dir[i][1];

          if (in(dx,dy))//如果在搜索地域
          {
               if (map[dx][dy]!='|'&&!visi[dx][dy])//如果满足搜索继续搜索的条件
               {
                  DFS(dx,dy);//继续搜索
               }
          }

      }
      visi[x][y]=false;//视情况是否需要回溯
}

广度搜索

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int m=4,n=3;
typedef pair<int,int> Position;
vector< vector<Position> > father(m,vector<Position>(n));//记录每个坐标的父节点
vector< vector<int> > Map(m,vector<int>(n));
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
bool in(int x,int y)
{
    return 0<=x&&x<m&&0<=y&&y<n;
}
void Print_Path()//打印路径
{
    int x=0,y=0;
     while (x!=-2&&y!=-2)
     {
        cout<<x<<","<<y<<"\n";
         int tem=x;
         x=father[x][y].first;
         y=father[tem][y].second;
     }
}
void BFS()
{
    queue<Position> q;
    q.push(Position(m-1,n-1));
    Map[m-1][n-1]=2;
    father[m-1][n-1]=Position(-2,-2);
     while (!q.empty())
     {
        Position tem=q.front();
        q.pop();
         for (int i=0;i<4;i++ )
         {
            Position  now;
            now.first=tem.first+dir[i][0];
            now.second=tem.second+dir[i][1];
            if(in(now.first,now.second))
            {
                  if(Map[now.first][now.second]==-1)//如果到达起始位置，则说明存在最路径
                  {
                    father[now.first][now.second]=tem;
                    Print_Path();
                    return;
                  }
                  if(Map[now.first][now.second]==0)
                  {
                      father[now.first][now.second]=tem;
                      Map[now.first][now.second]=2;
                      q.push(now);
                  }
             }
         }
     }
}

二叉排序模板

#include <iostream>
using namespace std;
 class Node
{
public:
    int data;
    Node* left;
    Node* right;
    Node(int value)
    {
        left=NULL;
        right=NULL;
        data=value;
    }
};

void CreatTree(Node* root, int* data, int index, int len, Node* start)
{
	if (index > (len - 1))
	{
		return;
	}
	Node*  newNode = new Node(data[index]);
	if (data[index] > root->data)
	{
		if (root->right == NULL)
		{
			root->right = newNode;
			index++;
			CreatTree(start, data, index, len, start);
		}
		else
		{
			CreatTree(root->right, data, index, len, start);
		}


	}
	else
	{
		if (root->left == NULL)
		{
			root->left = newNode;
			index++;
			CreatTree(start, data, index, len, start);
		}
		else
		{
			CreatTree(root->left, data, index, len, start);
		}

	}
}

void ZhongPrint(Node* root)
{
	if (root == NULL)
	{
		return;
	}
	ZhongPrint(root->left);
	cout << root->data;
	ZhongPrint(root->right);
}

int main()
{
    int n;
    cin>>n;

     int* nums=new int[n];
     for(int i=0;i<n;i++ )
     {
        cin>>nums[i];
     }
    Node* root=new Node(nums[0]);
    CreatTree(root,nums,1,n,root);
    ZhongPrint(root);
    return 0;
}

二分

int Dichodomy(int* nums,int start,int end,int target)
{
      if (end-start==1)
      {
          if (nums[end]==target)
          {
             return end;
          }
          else
          {
              return start;
          }
      }
     int left=start;
     int right=end;
     int mid=(start+end)/2;

     if (nums[mid]<target)//nums[mid]<target 的判断视具体题目情况而定，在某些题目中可能是一个复杂的判端
     {
          Dichodomy(nums,mid,end,target);
     }
     else if(nums[mid]>target)
     {
          Dichodomy(nums,start,mid,target);
     }
     else
     {
         return mid;
     }

}

树状数组模板

#include <iostream>
#include <vector>
using namespace std;
int maxindexx=1000010;
vector<int> nums(maxindexx);
int lowebit(int x)
{
   return x&(-x);
}
void add(int index,int addvalue)
{
     for (int i=index;i<maxindexx;i+=lowebit(i))
     {
        nums[i]+=addvalue;
     }
}

int quene(int r)
{
    int res=0;
     for (int i=r;i>0;i-=lowebit(i))
     {
       res+=nums[i];
     }
     return res;
}