版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zs391077005/article/details/84696954
- 快排
int partition(int a[],int left,int right)
{
int temp=a[left];
while(left<right&&temp<a[right])
right--;
a[left]=a[right];
while(left<right&&a[left]<=temp)
left++;
a[right]=a[left];
a[left]=temp;
return left;
}
void quicksort(int a[],int left,int right)
{
if(left<right)
{
int pos=partition(a,left,right);
quicksort(a,left,pos-1);
quicksort(a,pos+1,right);
}
}
- 归并排序
//[1,n]
int n;
void mergesort(int a[])
{ //step/2为左边区间元素个数
for(int step=2;step/2<=n;step*=2)
for(int i=1;i<=n;i+=step)
sort(a+i,a+min(i+step,n+1);
}
- 二分查找
//[0,n) 找第一个>x
int binarysearch(int a[],int left,int right)
{
int mid;
while(left<right)
{
mid=(left+right)/2;
if(a[mid]>x)//根据条件改此
right=mid;
else left=mid+1;
}
return left;
}
//[0,n-1]
int binarysearch(int a[],int left,int right,int target) {
int mid;
while(left<=right) {
mid = left + (right - left) / 2;
if(a[mid] == target)
return mid;
else if(a[mid] > target)
right = mid - 1;
else left = mid + 1;
}
return -1;
}
- 最大公约
int gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}
- 素数判断
bool isprime(int n)
{
if(n<=1) return false;
for(int i=2;i*i<=n;i++)
if(n%i==0)
return false;
return true;
}
- 堆排序
//大顶堆 [1,n]
const int maxn=100;
int heap[maxn];
void downadjust(int left,int right)
{
int i=left,j=i*2;
while(j<=right)
{
if(j+1<=right&&heap[j+1]>heap[j])
j=j+1;
if(heap[j]>heap[i])
{
swap(heap[i],heap[j]);
i=j;j=2*i;
}
else break;
}
}
void upadjust(int left,int right)
{
int i=right,j=i/2;
while(j>=left)
{
if(heap[j]<heap[i])
{
swap(heap[i],heap[j]);
i=j;j=i/2;
}
else break;
}
}
//建删 插排
void createheap(int left,int right)
{
for(int i=n/2;i>=1;i++)
downadjust(i,n);
}
void deletetop()
{
heap[1]=heap[n--];
downadjust(1,n);
}
void insert(int x)
{
heap[++n]=x;
upadjust(1,n);
}
void heapsort()
{
createheap();
for(int i=n;i>1;i--)
{
swap(heap[i],heap[1]);
upadjust(1,i-1);
}
}
- 并查集
int father[1010];
int findfather(int x)
{
int a=x;
while(x!=father[x])
x=father[x];
while(a!=father[a])
{
int z=a;
a=father[a];
father[z]=x;
}
return x;
}
void Union(int a,int b)
{
int faa=findfather(a);
int fab=findfather(b);
if(faa!=fab)
father[faa]=fab;
}
void init()
{
for(int i=0;i<n;i++)
father[i]=i;
}
//n个人,每个人k个课,若有相同课在一个社交圈,统计圈子数
//course[课]=人
int cyclenum()
{
int course[1010];
bool isroot[1010];
int cnt=0;
fill(course,course+1010,0);
for(int i=1;i<=n;i++)
{
for(int j=0;j<k;j++)
{
cin>>t;
if(course[t]==0)
course[t]=i;
Union(i,findfather(course[t]));
}
}
for(int i=1;i<=n;i++)
{
isroot[findfather(i)]++;
}
for(int i=1;i<=n;i++)
{
if(isroot[i]!=0)
cnt++;
}
return cnt;
}
- AVL树
struct node {
int val;
struct node *left,*right;
};
struct node *leftrotate(struct node *root)
{
struct node *temp=root->right;
root->right=temp->left;
temp->left=root;
return temp;
}
struct node *rightrotate(struct node *root)
{
struct node *temp=root->left;
root->left=temp->right;
temp->right=root;
return temp;
}
struct node *leftrightrotate(struct node *root)
{
root->left=leftrotate(root->left);
root=rightrotate(root);
return root;
}
struct node *rightleftrotate(struct node *root)
{
root->right=rightrotate(root->right);
root=leftrotate(root);
return root;
}
int getheight(struct node *root)
{
if(root==NULL)
return 0;
int l=getheight(root->left);
int r=getheight(root->right);
return l>r?l+1:r+1;
}
struct node *insert(struct node *root,int val)
{
if(root==NULL)
{
root=new node();
root->left=root->right=NULL;
root->val=val;
return root;
}
if(val<root->val)
{
root->left =insert(root->left,val);
int l=getheight(root->left);
int r=getheight(root->right);
if(l-r>=2)
{
if(val<root->left->val) //LL
{
root=rightrotate(root);
}
else root=leftrightrotate(root); //lr
}
}
else{
root->right=insert(root->right,val);
int l=getheight(root->left);
int r=getheight(root->right);
if(r-l>=2)
{
if(val>root->right->val)
{
root=leftrotate(root);
}
else root=rightleftrotate(root);
}
}
return root;
}
- levelOrder
#include<vector>
#include<queue>
using namespace std;
struct node {
int val;
struct node *left,*right;
};
vector<int> levelorder(struct node *root)
{
vector<int> v;
queue<struct node*> q;
q.push(root);
while(!q.empty())
{
node *top=q.front();
v.push_back(top->val);
q.pop();
if(top->left!=NULL)
q.push(top->left);
if(top->right!=NULL)
q.push(top->right);
}
return v
}
- dijkstra
#include<vector>
using namespace std;
//单一解
const int inf=999999999;
int dis[1010],e[1010][1010],pre[1010];
bool visit[1010];
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,inf):
fill(visit,visit+1010,false);
int pre[1010];
int st,end;
dis[st]=0;
void dfspre(int v)
{
if(v==end)
return;
cout<<v<<' ';
dfspre(pre[v]);
}
for(int i=0;i<n;i++)
{
int u=-1,minn=inf;
for(int j=0;j<n;j++)
{
if(visit[j]==false&&dis[u]<minn)
{
minn=dis[u];
u=j;
}
}
if(u==-1) break;
visit[u]=true;
for(int v=0;v<n;v++)
{
if(visit[v]==false&&e[u][v]!=inf)
{
if(dis[u]+e[u][v]<dis[v])
{
dis[v]=dis[u]+e[u][v];
pre[v]=u;
}
else if(dis[u]+e[u][v]==dis[v])
{
pre[v]=u;
}
}
}
}
dfspre(end);
//多路径取点个数少的
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,in):
fill(visit,visit+1010,false);
dis[st]=0;
vector<int> pre[1010];
vector<int> path,temppath;
int tempcnt=0,mincnt=9999999;
void dfsfrompre(int v)
{
temppath.push_back(v);
if(v==st)
{
if(temppath.size()<mincnt)
{
mincnt=temppath.size();
path=temppath;
}
temppath.pop_back();
return;
}
for(int i=0;i<pre[v].size();i++)
{
dfsfrompre(pre[v][i]);
}
temppath.pop_back();
}
for(int i=0;i<n;i++)
{
int u=-1,minn=inf;
for(int j=0;j<n;j++)
{
if(visit[j]==false&&dis[v]<minn)
{
u=j;
minn=dis[v];
}
}
if(u==-1) break;
visit[u]=true;
for(int v=0;v<n;v++)
{
if(visit[v]==false&&e[u][v]<inf)
{
if(dis[u]+e[u][v]<dis[v])
{
dis[v]=dis[u]+e[u][v];
pre[v].clear();
pre[v].push_back(u);
}
else if(dis[u]+e[u][v]==dis[v])
{
pre[v].push_back(u);
}
}
}
}
dfsfrompre(end);
//最短路径下,点权最大的
const int inf=999999999;
int dis[1010],e[1010][1010],pre[1010],weight[1010],w[1010][1010];
bool visit[1010];
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,inf):
fill(visit,visit+1010,false);
dis[st]=0;
int pre[1010];
for(int i=0;i<n;i++)
{
int u=-1;minn=inf;
for(int j=0;j<n;j++)
{
if(visit[i]==false&&dis[u]<minn)
{
minn=dis[u];
u=j;
}
}
if(u==-1) break;
visit[u]=true;
for(int v=0;v<n;v++)
{
if(visit[v]==false&&e[u][v]<inf)
{
if(dis[u]+e[u][v]<dis[v])
{
dis[v]=dis[u]+e[u][v];
weight[v]=weight[u]+w[u][v];
pre[v]=u;
}
else if(dis[u]+e[u][v]==dis[v]&&weight[u]+w[u][v]>weight[v])
{
weight[v]=weight[u]+w[u][v];
pre[v]=u;
}
}
}
}
- sort
//pre+post in?
#include<vector>
using namespace std;
int pre[1010],post[1010];
vector<int> in;
void setin(int prel,int prer,int postl,int postr)
{
int i=prel+1;
while(i<=prer&&pre[i]!=post[postr-1])
if(prel==prer)
{
in.push_back(pre[prel]);
return;
}
if(pre[prel]==post[postr])
{
if(i-prel>1)
{
setin(prel+1,i-1,postl,postl+i-prel-2);
in.push_back(post[postr]);
setin(i,prer,postl+i-prel-2+1 ,postr-1);
}
else
{
in.push_back(post[postr]);
setin(i,prer,postl+i-prel-2+1 ,postr-1);
}
}
}
//post+in level?
int post[1010],in[1010];
vector<int> level;
void getlevel(int inl,int inr,int postl,int postr,int index)
{
int i=inl;
while(i<=inr&&in[i]!=post[postr])
i++;
if(inl>inr) return;
level[index]=post[postr];
getlevel(inl,i-1,postl,i-1-inl+postl,index*2+1);
getlevel(i+1,inr,i-inl+postl,index*2+2);
}
//pre+in level?
int pre[1010],in[1010];
int level[1010];
void getlevel(int prel,int prer,int inl,int inr,int index)
{
if(prel>prer) return ;
int i=inl;
while(i<inr&&pre[prel]!=in[i]) i++;
level[index]=pre[prel];
getlevel(prel+1,i-inl-1-prel-1 ,inl,i-1,2*index+1);
getlevel(i-prel-1-inl,prer,i+1,inr,2*index+2);
}
//pre+in post?
int pre[1010],in[1010];
vector<int> post;
void postorder(int prel,int prer,int inl,int inr)
{
int i=prel+1;
while(i<=prer&&in[i]!=pre[prel])
i++;
postorder(prel+1,inl-i-prel ,inl,i-1);
postorder(inl-i-prel+1,prer,i+1,inr);
post.push_back(pre[prel]);
}
//in+post zigzag?
# include<queue>
using namespace std;
int in[1010],post[1010],tree[1010][2];
vector<int> result;
struct node{
int index,depth;
node(){}
node(int _index,int _depth) {index=_index;depth=_depth;}
};
void dfs(int &index,int inl,int inr,int postl,int postr)
{
if(inl>inr) return;
index=postr;
int i=inl;
while(i<=inr&&in[i]!=post[postr]) i++;
dfs(tree[index][0],inl,i-1,postl,i-1-inl+postl);
dfs(tree[index][1],i+1,inr,i-1-inl+postl+1,postr-1);
}
void bfs()
{
queue<node> q;
q.push(node{root,0});
while(!q.empty())
{
node *top=q.front();
q.pop();
result[temp.depth].push_back(post[temp.index]);
if(tree[temp.index][0]!=0)
q.push(node(tree[temp.index][0],temp.depth+1));
if(tree[temp.index][1]!=0)
q.push(node(tree[temp.index][1],temp.depth+1));
}
}
- AOE
#include<fstream>
#include <cstdio>
#include <iostream>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
using namespace std;
struct edge{
int v,w;
edge(){}
edge(int _v,int _w){v=_v;w=_w}
};
const int maxn=9999999;
vector<edge> g[maxn];
vector<int> activity[maxn];
int indegree[maxn]={0};
int n,m,indegreeorigin[maxn]={0};
int ve[maxn],vl[maxn];
stack<int> toporder;
bool topologicalsort()
{
queue<int> q;
for(int i=0;i<n;i++)
{
if(indegree[i]==0)
q.push(i);
}
while(!q.empty())
{
int u=q.front();
q.pop();
toporder.push(u);
for(int i=0;i<g[u].size();i++)
{
int v=g[u][i].v;
indegree[v]--;
if(indegree[v]==0)
{
q.push(u);
}
if(ve[u]+g[u][i].w>ve[v])
{
ve[v]=ve[u]+g[u][i].w;
}
}
}
if(toporder.size()==n)
return true;
else return false;
}
int criticalpath()
{
memset(ve,0,sizeof(ve));
if(topologicalsort()==false)
return -1;
int maxlength=0;
for(int i=0;i<n;i++)
{
if(maxlength<ve[i])
maxlength=ve[i];
}
fill(vl,vl+1010,maxlength);
while(!toporder.empty())
{
int u=toporder.top();
toporder.pop();
for(int i=0;i<g[u].size();i++)
{
int v=g[u][i].v;
if(vl[v]-g[u][i].w<vl[u])
vl[u]=vl[v]-g[u][i].w;
}
}
for(int u=0;u<n;u++)
{
for(int i=0;i<g[u].size();i++)
{
int v=g[u][i].v,w=g[u][i].w;
int e=ve[u],l=vl[v]-w;
if(e==l)
activity[u].push_back(v);
}
}
return maxlength;
}
vector<int> cpath;
void printcriticalpath(int u)
{
if(activity[u].size()==0)
{
cpath.push_back(u);
for(int i=0;i<cpath.size();i++)
{
printf("%d",cpath[i]);
}
cpath.pop_back();
return;
}
cpath.push_back(u);
sort(activity[u].begin(),activity[u].end());
for(int i=0;i<activity[u].size();i++)
printcriticalpath(activity[u][i]);
cpath.pop_back();
}
int main()
{
cin>>n>>m;
for(int i=0;i<m;i++)
{
int u,v,w;
cin>>u>>v>>w;
g[u].push_back(edge(u,v));
indegree[v]++;
indegreeorigin[v]++;
}
int criticaltime=criticalpath();
if(criticaltime==-1)
cout<<"NO"<<endl;
else
{
cout<<"YES"<<endl;
for(int i=0;i<n;i++)
{
if(indegreeorigin[i]==0&&activity[i].size()!=0)
printfcriticalpath(i);
}
}
#ifdef _DEBUG
system("pause");
#endif
return 0;
}
- bst
//BST树,已知前序求后序
const int maxn=1010;
vector<int> post;
int pre[maxn];
void getpost(int prel,int prer)
{
if(prel>prer) return ;
int i=prel+1,j=prer;
while(i<=prer&&pre[i]<pre[prer]) i++;
while(j>prel&&pre[j]>=pre[prel]) j--;
if(i-j!=1) return;
getpost(prel+1,j);
getpost(i,prer);
post.push_back(pre[prel]);
}
//如果post.size()==n 是bst树
//bst中序从小到大, 求层序
vector<int> in,level;
void levelorder(int inl,int inr,int index)
{
if(inl>inr) return;
int n=inr-inl+1;
int l=log(n+1)/log(2);//高-1
int leave=n-(pow(2,l)-1);
int root=inl+pow(2,l-1)-1+min(leave,pow(2,l-1));
level[index]=in[root];
levelorder(inl,root-1,2*index+1);
levelorder(root+1,inr,2*index+2);
}
14.肿瘤那个
struct node{
int x,y,z;
};
int m,n,l;
int X[6]={1,0,0,-1,0,0};
int Y[6]={0,1,0,0,-1,0};
int Z[6]={0,0,1,0,0,-1};
bool visit[1300][130][80];
int arr[1300][130][80];
bool judge(int x,int y,int z)
{
if(x<0||y<0||z<0||x>=m||y>=n||z>=l)
return false;
if(arr[x][y][z]==0||visit[x][y][z]==true)
return false;
return true;
}
int bfs(int x,int y,int z)
{
int cnt=0;
node temp;
temp.x=x;temp.y=y;temp.z=z;
queue<node> q;
q.push(temp);
visit[x][y][z]=true;
while(!q.empty())
{
node top=q.front();
q.pop();
cnt++;
for(int i=0;i<6;i++)
{
int tx=temp.x+X[i];
int ty=temp.y+Y[i];
int tz=temp.z+Z[i];
if(judge(tx,ty,tz))
{
visit[tx][ty][tz]=true;
temp.x=tx;temp.y=ty;
temp.z=tz;
q.push(temp);
}
}
}
if(cnt>=t)
return cnt;
else return 0;
}
- 地铁题
vector<int> path,temppath;
int line[10000][10000],visit[10000];
int transfercnt(vector<int> a)
{
int cnt=-1,preline=0;
for(int i=1;i<a.size();i++)
{
if(line[a[i-1]][a[i]]!=preline)
cnt++;
}
return cnt;
}
void dfs(int node, int end,int cnt.int &mincnt,int &mintransfer)
{
if(node==end&&cnt<mincnt||cnt==mincnt&&transfercnt(temppath)<mintransfer)
{
mincnt=cnt;
mintransfer=transfercnt(temppath);
path=temppath;
}
if(node==end) return;
for(int i=0;i<v[node].size();i++)
{
if(visit[v[node][i]==0)
{
visit[v[node][i]]=1;
temppath.push_back(v[node][i]);
dfs(v[node][i],end,cnt+1,mincnt,mintransfer);
visit[v[node][i]]=0;
temppath.pop_back();
}
}
}
- 运算符重载,达到set排序目的
struct node{
int value,cnt;
node(int a,int b){value=a;cnt=b;}
bool operator < (const node &a) const{
return cnt!=a.cnt?cnt>a.cnt:value<a.value;
}
}
//cnt从大到小,value从小到大
set<node> s;
s.insert(node(value,cnt));
//cnt用book[]记录
- 层序+中序 求先和中
#include<fstream>
#include <cstdio>
#include <iostream>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
using namespace std;
const int maxn=50;
const int inf=0x3ffffffff;
struct node
{
int data, left,right;
}Node[maxn];
int in[maxn];
vector<int> pre,post;
int num=0;
int newNode(int x)
{
Node[num].data=x;
Node[num].left=-1;
Node[num].right=-1;
return num++;
}
int create(vector<int> level,int inl,int inr)
{
if(level.size()==0)
return -1;
int root=newNode(level[0]);//root层序根
int k=inl;
while(k<=inr&&in[k]!=level[0]) k++;
//k中序根
vector<int> levelleft,levelright;
for(int i=1;i<level.size();i++)
{
bool isleft=false;
for(int j=inl;j<k;j++)
{
if(level[i]==in[j])
{
isleft=true;
break;
}
}
if(isleft) levelleft.push_back(level[i]);
else levelright.push_back(level[i]);
}
Node[root].left=create(levelleft,inl,k-1);
Node[root].right=create(levelright,k+1,inr);
return root;
}
void preorder(int root)
{
if(root==-1)
return ;
pre.push_back(Node[root].data);
preorder(Node[root].left);
preorder(Node[root].right);
}
void postorder(int root)
{
if(root==-1)
return;
post.push_back(Node[root].data);
postorder(Node[root].left);
postorder(Node[root].right);
}
int main()
{
vector<int> level;
int n,temp;
for(int i=0;i<n;i++)
{
cin>>temp;
level.push_back(temp);
}
for(int i=0;i<n;i++)
{
scanf("%d",&in[i]);
}
int root=create(level,0,n-1);
preorder(root);
postorder(root);
#ifdef _DEBUG
system("pause");
#endif
return 0;
}