系统性训练，励志刷完挑战程序设计竞赛-代码整理103~134【初级篇】

/*

*/
#include<iostream>
using namespace std;

/*
gcd辗转相除法，欧几里得算法

求解直线上的点，切割最小正方形
*/
int gcd(int x,int y){
return y==0?x:gcd(y,x%y);
}

/*
extgcd，扩展欧几里得算法
求解二元一次方程整数解 ax+by=c
返回函数=号右边的解c

囧：
int a声明一个int类型，名称叫a
int* a 声明一个int指针类型，名称叫a
int& a 声明一个int引用类型，名称叫a
*/

int extgcd(int a,int b,int&  x,int& y){
int d=a;
if(b!=0){
d=extgcd(b,a%b,y,x);
y-=(a/b)*x;
} else{
x=1;
y=0;
}
return d;
}

/*
快速幂运算
x^n mod m
*/
typedef long long ll;
ll mod_pow(ll x,ll n,ll m){
int res=1;
while(n>0){
if(n&1) res=res*x%m;  //如果n为奇数，原公式乘上x^(2^1),则res*x%m
x=x*x%m;
n>>=1;   //n/2
}
return res;
}

/*
大整数取模
n mod m

1234=(((1*10+2)*10+3)*10)+4 //每个括号内mod m一次，累积即可
*/

void big_mod(){
char n[100];
int m;
scanf("%s%d",n,&m);

int len=strlen(n);
int ans=0;
for(int i=0;i<len;i++){
ans=(int)(((ll)ans*10+n[i])%m);
}
printf("%d\n",ans);

}

/*
0~n以内的素数表

*/
bool is_prime(int x){
if(x==2) return true;
for(int i=2;i*i<x;i++){
if(x%i==0) return false;
}
return x!=1;
}
/*
打素数表
*/
void prime(){
int n;
int MAXN=1<<10;
int prime[MAXN],p=0;
bool is_prime[MAXN];
//memset(is_prime,true,sizeof(bool)*MAXN);
scanf("%d",&n);
for(int i=0;i<n;i++)is_prime[i]=true;
is_prime[0]=is_prime[1]=false;

for(int i=2;i<n;i++){
if(is_prime[i]){
prime[p++]=i; //存入素数表
for(int j=2*i;j<n;j+=i){  //非素打表
is_prime[j]=false;;
}
}
}
for(int i=0;i<p;i++)
printf("%d ",prime[i]);

}

int main(){

printf("%d\n",gcd(4,8));
int x=1,y=1;
printf("%d\n",extgcd(4,8,x,y));
//big_mod();
prime();

return 0;
}

/*
排序所有的边权，从小到大依次取出
判断是否该边两个节点是否在同一个连通分量
如果不在，合并MST。
*/
#include<iostream>
using namespace std;
const int MAXN=1<<10;
struct edge{
int u,v,cost;
};
edge es[MAXN];
int V,E;
int par[MAXN],rank[MAXN];
int comp(const edge& e1,const edge& e2){
return 	e1.cost<e2.cost;
}

void init(int N){
for(int i=0;i<N;i++){
par[i]=i;
rank[i]=0;
}
}
int find(int x){
if(par[x]==x) return x;
return par[x]=find(par[x]);
}

bool  same(int a,int b){
return find(a)==find(b);
}
void unite(int a,int b){
a=find(a),b=find(b);
if(a==b) return ;
if(rank[a]>rank[b])
par[a]=b;
else{
par[b]=a;
if(rank[a]==rank[b]) rank[a]++;
}
}

int kruskal(){
sort(es,es+E,comp);
init(V);
int res=0;
for(int i=0;i<E;i++){
edge e=es[i];
if(!same(e.u,e.v)){
unite(e.u,e.v);
res+=e.cost;
}
}
return res;
}

int main(){
kruskal();
return 0;
}

/*
与dijikstra算法
*/
#include<iostream>
using namespace std;
const int MAXN=1<<10;
int mincost[MAXN],cost[MAXN][MAXN]; //mincost[i],x集合到i节点的最小代价
bool used[MAXN];
int V;
int INF=(1<<31)-1;

int prim(){
fill(mincost,mincost+V,INF);
fill(used,used+V,false);
mincost[0]=0;
int res=0;

while(true){
int v=-1;
//在非x中选择最小权值的点
for(int i=0;i<V;i++){
if(!used[i]&&(v==-1 || mincost[i]<mincost[v]))
v=i;
}
if(v==-1) break;
used[v]=true;
res+=mincost[v]; //增加MST权重

//更新X集合，维护mincost
for(int u=0;u<V;u++){
mincost[u]=min(mincost[u],cost[v][u]);
}

}
return res;
}

int main(){
prim();
return 0;
}

/*
dijkstra算法，选最小点d更新边，即加边操作
适用于无负权的图问题

*/
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=1<<10;
int cost[MAXN][MAXN];//从u->v的权值
int V,d[MAXN],INF=(1<<31)-1;
bool used[MAXN];
int prev[MAXN];
/*
d[v],cost[u][v]来存储
*/
void dijkstra1(int s){
fill(d,d+V,INF);
fill(used,used+V,false);
fill(prev,prev+V,-1);
d[0]=0;
while(true){
int v=-1;
//选择一个没有使用的最小值的点
for(int u=0;u<V;u++){
if(!used[u] &&(v==-1 || d[u] <d[v])) v=u;
}
if(v==-1) break;  //未选择出来

used[v]=true;
//更新所有的点的最小距离   更新操作太多，浪费时间
for(int u=0;u<V;u++){
d[u]=min(d[u],d[v]+cost[v][u]);
prev[u]=v;
}

}
}
vector<int> get_path(int t){
vector <int >path;
for(;t!=-1;t=prev[t])
path.push_back(t);
reverse(path.begin(),path.end());
return path;
}

/*
采用邻接表+堆[查找最小值]，复杂度ElogV

*/

struct edge{
int to,cost;
};

vector<edge> G[MAXN];
typedef pair<int ,int> P; // first 代表最短距离，second代表顶点编号

void dijkstra2(int s){

priority_queue<P, vector<P>, greater<P> > que;
fill(d,d+V,INF);
que.push(P(0,s)); //初始化

while(!que.empty()){
P p= que.top(); que.pop();
int v=p.second;   //取出编号
if(d[v]<p.first) continue; //检查与d是否是最小的，确定是否更新d
for(int i=0;i<G[v].size();i++){  //更新v的连接边
edge e=G[v][i];
if(d[e.to]<d[v]+e.cost){
d[e.to]=d[v]+e.cost;
que.push(P(d[e.to],e.to));  //将更新后的最小边加入que
}
}
}

}

int main(){
dijkstra1(0);
dijkstra2(0);
return 0;
}