别催了马上交
别催了马上交

蓝桥杯算法总结

ACWing算法基础课笔记

闲来无事，利用阿里云做了个图床，已经将图片全部上传了。

1. 基础算法

1. 排序

快速：选择一个数，让数组中比他小的靠左，比他大的靠右，然后在左边右边同样进行操作。注意边界问题。O(nlogn)

一般选择mid

= l+r+1 >> 1，因为是用dowhile，所以设置i和j都是l和r往外一个。当i= j 说明左边都小于a[mid]，右边都大于a[mid]了，然后对于左边和右边再进行quick_sort，但是要注意左边是l,i-1,右边是i,r

#include
using namespace std;

const int N = 1e6 + 10;
int q[N];
int n;

void quick_sort(int q[],int l,int r){
	if(l>=r){
		return;
	}
	int x = q[(l+r+1)/2], i = l-1, j = r+1;//如果取左端点，则下面为q,l,j  q,j+1,r，如果取右端点,则下面为q,l,i-1  q,i,l （因为会出现死循环） 
	while(ix);
		if( i < j ) swap(q[i],q[j]);
	}	
	quick_sort(q,l,i-1);
	quick_sort(q,i,r);
}

int main(){
	scanf("%d",&n);
	for(int i=0;i

归并：先二分，让左边的和右边的排好大小后，再合并，合并时i <= mid && j <= r，如果左边大，就先放右边的，右边大就先放左边的，然后最后在进行没放完的放进去。可以两边都试试，因为一定是只有一边没放完，那么放完的那边就不会再进行了，然后让q数组从l开始到r结束，把temp数组中的复制一遍。

O(nlogn)

#include
using namespace std;
const int N = 1000010;
int q[N],tmp[N];
int n;

void merge_sort(int q[],int l,int r){
	if(l>=r){
		return;
	}
	int mid = (l+r)/2;
	merge_sort(q,l,mid);
	merge_sort(q,mid+1,r);
	int k=0,i=l,j=mid+1;
	while(i<=mid && j<=r){
		if(q[i]<=q[j]) tmp[k++]=q[i++];
		else tmp[k++]=q[j++];
	}
	while(i<=mid) tmp[k++]=q[i++];
	while(j<=r) tmp[k++]=q[j++];
	for(i=l,j=0;i<=r;i++,j++){
		q[i]=tmp[j];
	}
}


int main(){
	scanf("%d",&n);
	for(int i=0;i

逆序对就是当右边比左边小的时候就有逆序了，每次进行res += mid - i + 1；i代表了左边进行到哪里了。

2. 二分

只要有二段性的问题都可以使用二分去做。（二段性，在某段情况下满足条件的，其他的一连串情况不满足），比如牛棚问题，关押罪犯等，二分通常都是和别的算法联合起来用的。

2.1 整数二分（边界问题）

蓝桥杯算法总结_第1张图片

两个模板：第一个是找红色的边界的，第二个是找绿色的边界的

//check(mid)表示mid是否满足要找的那边的性质。
//红色边界
//找符合条件的右端点 
int bsearch_1(int l,int r){
	while(l
//绿色边界
//找符合条件的左端点
int bsearch_2(int l,int r){
	while(l

区别在于mid的选择以及r=mid-1和l=mid+1

mid的+1与否主要是找到最后两个r=l+1是否会死循环，左边端点不加1会死循环，因为找左边的端点最终是在左侧找到，就会经历r=l+1的情况,那么true就是l=mid=(l+r)/2=l，就一直死循环了，因此找左端点为mid = (l+r+1)/2

同理对右边的端点同样，因为是找右边的端点，因此最后一定是执行,r=mid的，如果mid=(l+r+1)/2，则r=mid=(r-1+r+1)/2=r，因此找右端点为mid=(l+r)/2

蓝桥杯算法总结_第2张图片

起始位置就是找右边≥x的端点，结束位置就是找左边≤x的端点，对应找右边的端点和左边的端点。

#include
using  namespace std;
const int N = 10e5+10;
int q[N],n,m;

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0;i>1;
			if(q[mid]>=x) r=mid;
			else l = mid+1;
		} 
		if(q[l]!=x){
			cout<<"-1 -1"<>1;
				if(q[mid]<=x) l=mid;
				else r = mid-1;
			}
			cout<

二分是只需要左边的数据有右边没有的特性就可以使用，不需要说一定是排序问题，比如左边的数都有1，右边的数没有1，找有1的数的右边界也是可以的。

2.2 浮点二分

无需考虑边界问题，直接二分即可

注意：解决问题的时候，精度最好比需要的要求小数点多两位，比如要求4位小数，精度就设置10-6，

题：开根问题

3. 高精度

大整数一般用数组来存。从小位开始存。如123 在数组中为 3 2 1。

3.1 A+B（两个大整数的和）：

加法就是注意相同位数相加数%10存本位，然后t = /10，然后放到下一位就行。

#include
#include
using namespace std;
vector add(vector &A,vector &B){//加引用是为了加快速度，如果不加引用也可以但是会先拷贝一遍就会慢很多
    vector C;
    int t=0;
    for(int i=0;i A,B;
    cin>>a>>b;
    for(int i = a.size()-1;i>=0;i--) A.push_back(a[i]-'0');//从小位开始存
    for(int i = b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    vector C = add(A,B);
    for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);
 	return 0;
}
3.2 A-B（两个大整数的减法）：

首先判断谁大，然后进行减法，用A-B，同样此处的t代表了当前的情况，t = A[i]-B[i]-t，如果t<0就把t变为-1，代表进了一位。注意最后输出的时候要去掉前面的0

#include
#include
using namespace std;

bool cmp(vector &A,vector &B){
	if(A.size()!=B.size()) return A.size()>B.size();
	for(int i=A.size()-1;i>=0;i--){
		if(A[i]!=B[i]){
			return A[i]-B[i];//从高位开始比较依次到最小位，只要有位数不同，就返回谁大谁小。 
		}
	}
	return true; 
} 

vector sub(vector &A,vector &B){
	vector C;
	int t=0;
	for(int i=0;i1&&C.back() == 0) C.pop_back();//这一步没考虑到，但是结果出来看到有0，肯定会改，很妙，C.size() ==0的时候当然要留一个0， 
//	for(int i=0;i A,B;
    cin>>a>>b;
    for(int i = a.size()-1;i>=0;i--) A.push_back(a[i]-'0');//从小位开始存
    for(int i = b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    vector C;
    if(cmp(A,B)){
    	C=sub(A,B);
		for(int i=C.size()-1;i>=0;i--){
			printf("%d",C[i]);
		} 
	}
    else{
    	C=sub(B,A);
    	printf("-");
    	for(int i=C.size()-1;i>=0;i--){
			printf("%d",C[i]);
		}
	}
 	return 0;
}
3.2 Axa，a为一个低精度的数即可以用int表示的。
#include
#include 
using namespace std;

vector mul(vector A,int b){
	int t=0;
	vector C;
	for(int i=0;i>a>>b;
	vector A;
	for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
	vector C;
	C = mul(A,b);
	for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);
	
}
3.2 A/a，a为一个低精度的数即可以用int表示的。
#include
#include
#include
using namespace std;

vector div(vector A,int b,int &r){
	vector C;
	r=0;
	for(int i=A.size()-1;i>=0;i--){
		r = r*10+A[i];
		C.push_back(r/b);
		r%=b;
	}
	reverse(C.begin(),C.end());
	while(C.size()>1 && C.back()==0) C.pop_back();
	return C;
}


int main(){
	string a;
	int b;
	cin>>a>>b;
	vector A;
	for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
	vector C;
	int r;
	C = div(A,b,r);
	for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);
	cout<

4. 前缀和 （可以类比概率中的P(a

当实现题目要求的过程中需要多次用到从某个位置到某个位置的和时使用，因为生成前缀和Sn只需要O(n)，之后的查询只需要O(1)，否则的话每次计算都需要O(n)，n次就是O(n^2)，其实就是前n项和

一维数组前缀和：

#include
using namespace std;

const int N=1e6+10;
int n,m;
int a[N],s[N];

int main(){
    //los::sync_with_stdio(false);//这个可以提高cin的速度但不能用scanf了
	scanf("%d%d",&n,&m);
	for(int i =1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n;i++) s[i]=s[i-1]+a[i];
	while(m--){
		int l,r; 
		scanf("%d%d",&l,&r);
		printf("%d\n",s[r]-s[l-1]);
	}
	return 0;	
}

二维数组前缀和：

#include
using namespace std;
const int N = 1e4+10;
int n,m,q;
int a[N][N],s[N][N];

int main(){
	scanf("%d %d %d",&n,&m,&q); 
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			scanf("%d",&a[i][j]);3
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			s[i][j]=s[i][j-1]+s[i-1][j]-s[i-1][j-1]+a[i][j];
	while(q--){
		int l1,r1,l2,r2;
		scanf("%d %d %d %d",&l1,&r1,&l2,&r2);
		printf("%d",s[l2][r2]-s[l2][r1-1]-s[l1-1][r2]+s[l1-1][l2-1]);
	}
	return 0;
}

5. 差分（可以看成是前缀和的逆运算）

有数组a1，a2,…，an，构造b1，b2，…，bn的前缀和数组为an。

蓝桥杯算法总结_第3张图片

不管是前缀和还是差分，都是为了在进行大量操作是降低时间复杂度。尽管这些操作可能都是很简单的，但是会占用很多的时间成本，因此产生了前缀和 和 差分数组，牢记前缀和 和 差分等价于前n项和数组Sn和数列数组an。

核心为insert。

一维数组差分：

#include
using namespace std;

const int N = 1e6+10;

int n,m;
int a[N],b[N];

void insert(int l,int r,int c){
	b[l]+=c;
	b[r+1]-=c;
}

int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	
	for(int i=1;i<=n;i++) insert(i,i,a[i]);
	
	while(m--){
		int l,r,c;
		scanf("%d %d %d",&l,&r,&c);
		insert(l,r,c);
	}
	for(int i=1;i<=n;i++) b[i]+=b[i-1];
	for(int i=1;i<=n;i++) printf("%d",b[i]);
	return 0;
	
}

二维数组差分：

#include
using namespace std;
const int N = 1e4+10;
int n,m,q;
int a[N][N],b[N][N];

void insert(int x1,int y1,int x2,int y2,int c){
	b[x1][y1]+=c;
	b[x2+1][y1]-=c;
	b[x1][y2+1]-=c;
	b[x2+1][y2+1]+=c; 
	
}
int main(){
	scanf("%d %d %d",&n,&m,&q); 
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			scanf("%d",&a[i][j]);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			insert(i,j,i,j,a[i][j]);
	while(q--){
		int x1,y1,x2,y2,c;
		scanf("%d %d %d %d %d",&x1,&y1,&x2,&y2,&c);
		insert(x1,y1,x2,y2,c);
	}
	for(int i=1;i<=n;i++) 
		for(int j=1;j<=m;j++)
			b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			printf("%d ",b[i][j]);
		}
		printf("\n");
	}
	return 0;
}

6. 双指针算法

核心思想：
for(int i=0;i

模板：

for(i=0,j=0;i

单个数组：

最长连续重复子序列

#include
using namespace std;
int main(){
	string a;
	int max=0,i,j;
	cin>>a;
	for(i=0;imax) max=j-i+1;
		i=j;
	}
	printf("%d",max);
}

最长连续不重复子序列

此处把j放在i的左侧也很妙，动态数组也很妙。

#include
using namespace std;


const int N =1e6+10;
int a[N];
int s[N];
int n;
 
int main(){
	cin>>n;
	for(int i=0;i1,判断是否重复，然后重复就s[a[j]]-- ，然后后移，这样子知道a[j]的值等于刚加进来的a[i]的值就可以停止，这个时候j-i这个区间就没有重复了 
		s[a[i]]++;
		while(s[a[i]]>1){
			s[a[j]]--;
			j++;
		}
		res = max(res,i-j+1);
	}	
	cout<

7. 位运算

取某个数二进制下k位数的值。(a>>k)&1

lowbit(x):取x二进制下最后一个1的数（x & (~x)），如lowbit(10101000)=1000，=8，随意Lowbit操作可以找到x中1的个数。

8. 离散化

通常是一个很大的范围但是里面的东西很稀疏，因此将其映射到一个小的范围了，并对每个下标有一个映射，之后通过下标找到映射后的就可以进行在原范围内同样的了。

区间离散化，

vector alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素

// 二分求出x对应的离散化的值
int find(int x) // 找到第一个大于等于x的位置
{
    int l = 0, r = alls.size() - 1;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
}

例题区间和

蓝桥杯算法总结_第4张图片

蓝桥杯算法总结_第5张图片

#include
#include 
#include 
#include

using namespace std;
typedef pair PII;

const int N = 300010;
int n,m;
int a[N],s[N];
vector alls;
vector add,query;

int find(int x){
	int l=0,r=alls.size()-1;
	while(l>1;
		if(alls[mid]>=x) r = mid;
		else l= mid+1;
	}
	return r+1; 
}

int main(){
	cin>>n>>m;
	for(int i=0;i>x>>c;
		add.push_back({x,c});
		
		alls.push_back(x);
	}
	for(int i=0;i>l>>r;
		query.push_back({l,r});
		alls.push_back(l);
		alls.push_back(r);
	}
	sort(alls.begin(),alls.end());
	alls.erase(unique(alls.begin(),alls.end()),alls.end());
	for(auto item : add){
		int x = find(item.first);
		a[x]+=item.second;
	}
	for(int i=1;i<=alls.size();i++) s[i] = s[i-1]+a[i];
	
	for(auto item: query){
		int l = find(item.first), r=find(item.second);
		cout<

由于这个要在gcc11上才能运行，因此我只在ACWing上利用在线环境编译过,auto也要在较高版本上才能用

9. 区间合并

交集区间合并。

蓝桥杯算法总结_第6张图片

#include
#include 
#include  
using namespace std;

typedef pair PII;
const int N = 100010;
int n;
vector segs;

void merge(vector &segs){
	vector res;
	
	sort(segs.begin(),segs.end());
	
	int st = -2e9,ed = -2e9;
	for(auto seg:segs)
		if(ed< seg.first){
			if(st != -2e9) res.push_back({st,ed});
			st = seg.first,ed = seg.second;
		}
		else ed = max(seg.second,ed);
	if(st != -2e9) res.push_back({st,ed});
} 

int main(){
	cin>>n;
	for(int i= 0;i>l>>r;
		segs.push_back({l,r});
	}
	merge(segs);
	cout<

2. 数据结构

1. 链表

head表示头结点。e[n]表示当前结点的value，ne[n]表示存储的下一个结点的位置，即e[ne[i]]表示i结点下一个结点的value。

#include
using namespace std;
const int N = 1e6;
//head头结点
//e[i]表示结点i的值
//ne[i]表示结点i的下一个结点是多少
//idx表示当前已经到了哪个结点
//用数组模拟数据结构是因为如果用结构体，然后new 结点的话，时间是很长的，长度稍微长点就会超时。
int e[N],ne[N],head,idx;

void init(){
	head = -1;
	idx = 0;
}
//将x插到头结点
void add_to_head(int x){//把x存到现在到的那个结点，然后把那个结点放在head头指针的后面,idx++就新的结点生成了。
	e[idx]=x
	ne[idx]=head;
	head = idx;
	idx++;
}
void remove(int k){
	ne[k]=ne[ne[k]];
} 

int main(){
	

}
1.1 单链表

蓝桥杯算法总结_第7张图片

直接判断输入的是什么后执行操作即可

1.2 双链表
#include
using namespace std;
const int N=1e6+10;
int l[N],r[N],e[N];
int n,index;
void init(){
	r[0]=1;
	l[1]=0;
	index=2;
} 
//在下标是k的右边加入结点x。 
//直接在下标是k的右边加是存在问题的。 
void add(int k,int x){
	e[index] = x;
	l[index] = k;
	r[index] = r[k];
	r[k] = index;
	l[r[index]] = index;
	index++;
}
void remove(int k){
	r[l[k]] = r[k];
	l[r[k]] = l[k];
}

int main(){
	init();
	add(0,5);
	add(0,10);
	for(int i=r[0];i!=1;i=r[i]){
		cout<
1.3 单调栈

蓝桥杯算法总结_第8张图片

算法一：

简单的两个for循环，第一个循环代表从0到n的第i个值。第二个for循环是从i到0找第一个小于i的值。

算法二：

利用单调栈，当存在 j < i , s t k j > s t k i jstk_i j<i,stkj​>stki​时，此时的 j j j是没有意义的，应该直接删掉的，因为对于后面的 k > i k>i k>i，对于 k k k的最近的小于 s t k k stk_k stkk​的一定是 s t k i stk_i stki​因此可以在栈中直接把j给删除了。如图：

蓝桥杯算法总结_第9张图片

显然，这样的图，对于后面还没有画出来的点，所有超过了最低点的都是无用的，所以最终有用的点图为：

蓝桥杯算法总结_第10张图片

仅有三个点时有用的，这三个点存在栈中，其他的都pop出来。

算法实现如下：

#include
using namespace std;
const int N = 1e6+10;

int n;
int stk[N],tt;

int main(){
	cin>>n;
	for(int i=0;i>x;
		while(tt && stk[tt] >= x) tt--;//如果栈内的＞=x，说明这些点对于i后面的来说是没有意义的，因此pop出去，直到目前栈中的都比x小，然后进行下一步。
		if(tt) cout<
1.4 单调队列

蓝桥杯算法总结_第11张图片

蓝桥杯算法总结_第12张图片

#include
using namespace std;
const int N = 1e6+10;
int a[N],q[N];
int n;

int main(){
	scanf("%d %d",&n,&k);
	for(int i=0;iq[hh]) hh++;//队内有元素且队头划出了窗口，则队头++。
		while(hh<=tt && a[q[tt]]>=a[i]) tt--; //队内有元素，判断队尾是否大于现在的这个点的值，如果大于，说明目前这个点是没有意义的，因此要pop这个队尾，和单调栈极其的相似，不过是现在加了个hh的队头用于判断元素个数。
		q[ ++ tt] = i;//把i这个点加入队列里去。
		if(i>=k-1) printf("%d ",a[q[hh]]);//这个队列中队头的点的数值即为滑动窗口的最小值。
	}
	//最大值则反过来即可。
    printf("\n") ;
	hh=0;tt=-1;
	for(int i=0;iq[hh]) hh++;
		while(hh<=tt && a[q[tt]]<=a[i]) tt--; 
		q[ ++ tt] = i;
		if(i>=k-1) printf("%d ",a[q[hh]]);
	}
	return 0;
}
1.5 KMP字符串配对

蓝桥杯算法总结_第13张图片

暴力：

S[N],P[m];
for(int i=1;i<=n;i++){
	bool flag = true;
	for(int j=1;j<=m;j++)
		if(s[i+j-1]!=p[j]){
            flag=false;
            break;
		}
}

优化：

第二个for循环不用每次都从1开始，由KMP匹配字符串可以得到如果从i开始不匹配，那么从i=next[i]开始循环即可。next[i]=j的意思是P[1j]=P[i-j+1i]

#include
using namespace std;
const int N = 1e4+10, M = 1e5+10;
int n,m;
char p[N],s[M];
int ne[N];


//生成next数组和匹配的过程是一样的。因为同样是字符串匹配，只是这里的字符串匹配是同一个字符串在匹配，当j=ne[j]后，p[i]==p[j+1]，意味着j的下一个字符是可以和i匹配上的，那么i的ne[i]=j+1。代表着i的最大前缀和字符串是j+1。
int main(){
	cin>>n>>p+1>>m>>s+1;
	//生成next数组
	 for(int i=2,j=0;i<=n;i++){
	 	while(j && p[i] != p[j+1]) j = ne[j];
	 	if(p[i] == p[j+1] ) j++;
	 	ne[i] = j;
	 	
	 }
	
	
	//kmp匹配过程 
	for(int i=1,j=0;i<=m;i++){
		while(j && s[i] != p[j+1] ) j = ne[j];
		if(s[i] == p[j+1] ) j++;
		if(j==n){
			//匹配成功
			printf("%d ",i-n);
			j = ne[j];//找出所有 
		}
	}
	return 0;	
}

蓝桥杯算法总结_第14张图片

每次的匹配成功可以让下一次有了前面匹配的基础，如果匹配不成功，则变为ne[j]，那么同样拥有前面匹配成功的基础，知道你的ne[j]=0，这意味着你没有前面的基础了，那么你如果匹配成功，那你的ne[i]=1，否则你没有ne[i]，所以你的ne[i]=0；这就是构造next[]数组的精髓。

2. Trie树

用于高效存储和查找字符串集合的数据结构

蓝桥杯算法总结_第15张图片类似关联规则中建造FP树。

存储：在结点打上标记代表这个地方有单词，如abcdef则在最左边的那个f处做个标记，现在要插入一个abc则在c那里加一个标记。

查找，按照步骤来，如abc，现在去查，虽然能完整走完，但是c这里没有标记，所以表示没有这个单词，如果是abcf，则是走完，也代表没有这个单词

蓝桥杯算法总结_第16张图片

#include
using namespace std;

const int N = 100010;
int son[N][26],cnt[N],idx;//son代表着第p个结点的的儿子结点是谁，cnt代表这个单词出现了几次。idx代表着第几个数组，标是0的点，既是根结点，又是空节点。 比如abc,son[0][0]就是存的a，然后son[0][0]=1,代表着cnt[1]即为a单词出现的次数 
char str[N];
void  insert(char str[]){
	int p=0;
	for(int i=0;str[i];i++){
		int u = str[i]-'a';
		if(!son[p][u]) son[p][u] = ++idx;
		p = son[p][u];
	}
	cnt[p]++;
}
int query(char std[]){
	int p=0;
	for(int i=0;str[i];i++){
		int  u = str[i]-'a';		
		if( !son[p][u]) return 0;
		p = son[p][u];
	}
    return cnt[p];
}
int main(){
	int n;
	scanf("%d",&n);
	while(n--){
		char op[2];
		scanf("%s%s",op,str);
		if(op[0] == 'I') insert(str);
		else printf("%d\n",query(str));
	}
	return 0;
}

son[i] [j]代表着第idx=i的位置的子结点[j]是否存在，同时记录他的idx。比如现在存入abcd和bcd和abcf，

首先存入abcd

son[0] [0] = ++idx = 1;

son[1] [1] = ++idx = 2;

son[2] [2] = ++idx = 3;

son[3] [3] = ++idx = 4;

cnt[4]++;

这样就储存完了abcd，在这基础上再储存bcd

son[0] [1] = ++idx = 5;

son[5] [2] = ++idx = 6;

son[6] [3] = ++idx = 7;

cnt[7]++;

这样就储存完了bcd，在这基础上在储存abcf,

son[0] [0]存在，所以直接做p = son[0] [0] =1;

son[p] [1]因为p=1，所以存在，所以直接做 p = son[1] [1] = 2;

son[2] [2]存在，所以做p = son[2] [2]=3;

son[3] [4] 不存在，所以son[3] [4] = ++idx = 8;

然后cnt[8]++;

可以看到idx只是提供了p走向下一个位置的方位，以及作为cnt数组提供数量的一个坐标。如son[1] [7]=10,代表着下一个结点走到了son[10] [u]，如果son[1] [7]就是结尾，则cnt[10]++;

蓝桥杯算法总结_第17张图片

蓝桥杯算法总结_第18张图片

例题：

蓝桥杯算法总结_第19张图片

解题思想：

首先将所有数字以二进制形式存入trie树中,如3:11,2:10,5:101。找最大值，然后从最前面的0开始往后搜索，如果最大值开始有数字，而该层有不同位的，就把地址改到不同位的层去，再从不同层的位比较是否数字相同，如果也有不同位的，然后再改地址，如图

蓝桥杯算法总结_第20张图片

#include
#include
using namespace std;
int const N=100010,M=31*N;

int n;
int a[N];
int son[M][2],idx;
//M代表一个数字串二进制可以到多长

void insert(int x)
{
    int p=0;  //根节点
    for(int i=30;i>=0;i--)
    {
        int u=x>>i&1;   /取X的第i位的二进制数是什么  x>>k&1(前面的模板)
        if(!son[p][u]) son[p][u]=++idx; ///如果插入中发现没有该子节点,开出这条路
        p=son[p][u]; //指针指向下一层
    }
}
int search(int x)
{
    int p=0;int res=0;
    for(int i=30;i>=0;i--)
    {                               ///从最大位开始找
    int u=x>>i&1;
	    if(son[p][!u]) 如果当前层有对应的不相同的数
	    {   ///p指针就指到不同数的地址	
	      p=son[p][!u];
	      res=res*2+1;
	         ///*2相当左移一位  然后如果找到对应位上不同的数res+1 例如    001
	    }                                                       ///       010 
	    else                                                      --->011                                                                           //刚开始找0的时候是一样的所以+0    到了0和1的时候原来0右移一位,判断当前位是同还是异,同+0,异+1
	    {
	        p=son[p][u];
	        res=res*2+0;
	    }
    }
    return res;
}
int main()
{
    cin.tie(0);
    cin>>n;
    idx=0;
    for(int i=0;i>a[i];
        insert(a[i]);
    }
    int res=0;
    for(int i=0;i

3. 并查集

将两个集合合并、询问两个元素是否在一个集合当中。

不用并查集第二个操作是O(1)，但是第一个操作要O(n)。用了并查集近乎都是O(1)

并查集的基础利用树来存储。同一颗树代表了同一个集合，根结点的编号就是这个集合的信息。每个结点存储它的父节点，p[x]表示x的父节点。

那么就有：

问题1：如何判断树根：if(p[x]==x)

问题2：如何判断x的集合编号：while(p[x]!=x) x = p[x];（路径压缩的优化）

问题3：如何合并两个集合：令一个树的父亲结点为p[x]=y即可，也就是让一个树的根结点指向另一个树的根结点，那么就合并了。

蓝桥杯算法总结_第21张图片

#include
using namespace std;
const int N = 1e5+10;
int p[N],n,m;

int find(int x)//返回x的祖宗结点，同时路径压缩 
{
		if(p[x] != x) p[x] = find(p[x]);
		return p[x];
} 

int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++) p[i] = i;
	while(m--){
		char op[2];//用字符串的读入时不用考虑空格啥的影响，比如这里你输入n,m时会有空格，如果是char s，那么在读入时就得考虑空格或者回车了。 
		int a,b;
		scanf("%s%d%d",op,&a,&b);
		if(op[0]=='M') p[find(a)] = find(b);
		else{
			if(find(a)==find(b)) cout<<"Yes"<

例题：连通块中点的数量

蓝桥杯算法总结_第22张图片

#include
using namespace std;
const int N = 1e5+10;
int p[N],n,m,size[N];

int find(int x)//返回x的祖宗结点，同时路径压缩 
{
		if(p[x] != x) p[x] = find(p[x]);
		return p[x];
} 

int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++){
		size[i]=1;
		p[i] = i;
	}
	while(m--){
		char op[2];//用字符串的读入时不用考虑空格啥的影响，比如这里你输入n,m时会有空格，如果是char s，那么在读入时就得考虑空格或者回车了。 
		int a,b;
		scanf("%s",op);
		if(op[0]=='C') {
			scanf("%d%d",&a,&b);
			if(find(a)==find(b)) continue;//判断是否在同一个集合中，防止做了翻倍。
			size[find(b)]+=size[find(a)];
			p[find(a)] = find(b);
		}
		else if (op[1]=='1')
		{
			scanf("%d %d",&a,&b);
			if(find(a)==find(b)) cout<<"Yes"<

4. 堆

基本操作：

1.插入一个数

2.求集合当中的最小值

3.删除最小值

4.删除任意一个元素

5.修改任意一个元素

堆是一颗完全二叉树（除最后一层非空，且最后一层从左到右）下标从1开始比较方便计算儿子结点，左儿子=2k,右儿子=2k+1

小根堆：根是最小值。

蓝桥杯算法总结_第23张图片

利用其完全二叉树的性质用一维数组存储。

操作down(x)：

蓝桥杯算法总结_第24张图片

void down(int k)
{
	int t = k;
	if(k*2<=size && heap[k*2] < heap[t]) t = k*2;
	if(k*2+1

操作up(x)：则是从下往上移动。

void up(int k){
	while(heap[k]

有了up和down后就可以做上面的五种操作了；

插入一个数就是在最后一个结点的后面插入一个数，然后up

heap[++size] = x;up(size);

求集合中最小值则是heap[1];

删除最小值则是把最后一个元素覆盖到第一个元素，然后–size;down(1)

删除任意一个元素heap[k] = heap[size];size–;down(k);up(k);

修改任意一个元素heap[k] = x;down(k);up(k);

堆排序：

蓝桥杯算法总结_第25张图片

#include
using namespace std;
const int N = 1e6+10;
int heap[N],size,n,m; 
void down(int k){
	//自己写的 
//	int zko = 2*k,yok = 2*k+1;
//	if(yok<=size){
//		if(heap[zko]=size && yok

模拟堆：

蓝桥杯算法总结_第26张图片

#include
#include
using namespace std;
const int N = 1e6+10;
int ph[N],hp[N];//ph[k]第k个插入的点的下标.hp[k]堆里的第k个点时第几次插入的。 
int heap[N],size,n,m; 

void heap_swap(int i,int j){
	swap(heap[i],heap[j]);
	swap(ph[hp[i]],ph[hp[j]]);
	swap(hp[i],hp[j]);
}



void down(int k){
	int t = k;
	if(k*2<=size && heap[k*2] < heap[t]) t = k*2;
	if(k*2+1>op;
		if(!strcmp(op,"I")){
			scanf("%d",&x);
			size++;
			m++;
			ph[m] = size;
			hp[size] = m;
			heap[size] = x;
			up(size);
		}
		else if(!strcmp(op,"PM")) printf("%d",heap[1]);
		else if(!strcmp(op,"DM")){
			heap_swap(1,size);
			size -- ;
			down(1);
		}
		else if(!strcmp(op,"D")){
			scanf("%d",&k);
			k = ph[k];
			heap_swap(k,size);
			size -- ;
			down(k),up(k);
		}
		else{
			scanf("%d %d",&k,&x);
			k = ph[k];
			heap[k] = x;
			down(k),up(k);
		}
	}
	return 0;
}

5. Hash 表

把一个庞大的空间通过哈希函数小的空间里。

离散化是一种特殊的哈希方式

存储结构：开放寻址法、拉链法

开放寻址法：

开放寻址法和拉链法类似，但是这里就是没有拉链这样子的处理冲突的方式，开放寻址法的数组是比拉链法的大小大的，大概是2-3倍左右的大小，哈希的方式同样是h(x)，这里处理冲突是往下一个顺位走，比如h(x) = 3，然后在3这里有人，就往4放，如果还有人，就依次到没有人的地方

开一个数组，然后按照哈希函数把原始映射的现在的数组中。如果存在冲突，则在数组的该位置后面加上一个结点，类似一个拉链。

蓝桥杯算法总结_第27张图片

例题：

蓝桥杯算法总结_第28张图片

拉链法：

#include
#include
using namespace std;

const int N = 1e5+3;//取靠近需要空间的最小的质数 

int h[N],e[N],ne[N],idx;
//h[i]中存的是第i个数组位置指向的结点。e[i]是第i个结点的值，ne[i]是第i个结点的下一个结点。
 
//插入是让x插在第i个数组位置的第一个，即ne[idx]=h[k] h[k] = idx;
void insert(int x){
	int k = (x % N + N ) % N;//担心有负数 
	e[idx] = x;
	ne[idx] = h[k];
	h[k] = idx++;
}

bool find(int x){
	int k = (x%N+N)%N;
	for(int i = h[k];i != -1; i = ne[i]){
		if(e[i] == x) return true;
	}
	return false;
}

int main(){
	int n;
	cin>>n;
	memset(h,-1,sizeof h);
	while(n--){
		char op[2];
		int x;
		scanf("%s%d",op,&x);
		if( *op == 'I') insert(x);
		else{
			if(find(x)) puts("Yes");
			else puts("No");
		}
	}
	return 0;
}

开放寻址法：

#include
#include
using namespace std;
const int N = 2e5+3,null = 0x3f3f3f3f;
int h[N],n;

int find(int x){
	int k = (x % N + N) % N;
	while(h[k] != null && h[k] != x){
		k++;
		if(k==N) k = 0;
	}
	return k;
}

int main(){
	cin>>n;
	memset(h,0x3f,sizeof h);//memset是把每个字节都赋成0x3f，由于int是4字节，那么就是0x3f3f3f3f, 
	//在拉链法中的-1，就是每个字节都是-1,由于-1表示是都是1,那么4个字节都是1，也就意味着最终的也是-1
	//如果是0，那么就是每个字节都是0，4个字节也就是0，一般就这几种赋值的方法 
	while(n--){
		char op[2];
		int x;
		scanf("%s%d",op,&x);
		int k = find(x);
		if(*op == 'I') h[k] = x;
		else {
			if(h[k] != null) puts("Yes");
			else puts("No");
		}
	}
}
字符串哈希方式：

首先预处理出来所有字符串的前缀哈希值

蓝桥杯算法总结_第29张图片

把字符串看成一个p进制的数

注意事项：（不能产生冲突）这就意味着p最最最小得大于26，不能映射为0，同样是为了防止出现冲突。

①不能映射为0

②Rp足够好，不存在冲突 通常p=131或者13331，Q = 2 64 2^{64} 264

例题：

蓝桥杯算法总结_第30张图片

#include
#include
using namespace std;
typedef unsigned long long ULL;

const int N = 1e5+10,P = 131;

int n,m;
char str[N];
ULL h[N],p[N];//h[i]代表的是这个字符串str的前i个字符对应的哈希值，比如JXUFEACWING ,h[1]则为"J"代表的哈希值，h[2]则为"JX"代表的哈希值，且h[2] = h[1] * p + str[2] 
//p[i]单纯代表了p的i次方而已 ,因此有get(l,r) = h[r] - h[l-1] * p [r-l+1]，因为h[r]是p^r次方的，h[l-1]是p^l-1次方的，所以要*p^r-l+1次方，然后用h[r]-h[l-1]*p[r-l+1]才剩下l到r区间的哈希值。且此时的值为p^r-l+1次方的范围。 
ULL get(int l, int r){
	return h[r] - h[l-1] * p[r-l+1];//这里把p[r-l+1]改为pow(P,r-l+1)也是可以的 
}

int main(){
	scanf("%d%d%s",&n,&m,str+1);
	p[0] = 1;
	for(int i = 1; i <= n; i ++){
		p[i] = p[i - 1] * P;
		h[i] = h[i - 1] * P +str[i];
	}
	while(m -- ){
		int l1,r1,l2,r2;
		scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
        if(get(l1,r1) == get(l2,r2)) puts("Yes");
        else puts("No");
	}
	return 0;
	
}

STL使用

vector，变长数组：

size()长度；empty()是否为空；clear()清空；front()/back()第一个或者最后一个；push_back()/pop_back()插入或者删除最后一个数；begin()/end()

pair，二元组：

pair> 三元组

当需要存储两种不同的元素时，需要排序的放在first里不需要排序的放在second

p.first/p.second第一个或者第二个元素;支持比较运算

string，字符串

substr(1，2)第一个参数是初始位置，第二个参数是长度，下标从0开始，如果长度太长，则会输出到最后一个位置为止，也可以省略第二个参数，代表从初始位置到最后一个位置；c_str()；size()；empty()；clear()

queue，队列

push()向队尾插入；front()返回队头元素；back()返回队尾元素；pop()弹出队头元素

priority_queue，优先队列，默认大根堆

push()插入一个元素；top()返回堆顶元素；pop()弹出堆顶元素

stack，栈

push()向栈顶插入一个元素；top()返回栈顶元素；pop()弹出栈顶元素

deque，双端队列，速度慢，但功能多

size()；empty()；clear()；front()；back()；push_back()/pop_back()；push_front()/push_front()；begin()/end()

set,map,multiset,multimap，基于平衡二叉树实现（红黑树），动态维护有序序列

set中不能有重复元素，如果有插入重复元素，这个操作会被忽略掉，multiset可以有重复元素

size()；empty()；clear()；begin()/end() ++，-- 但会前驱和后继

set/multiset:

insert()插入一个数；find()查找一个数；count()返回一个数的个数；erase()，如果是输入一个数x，就是删除所有数x 时间是O（k+logn）,如果输入时一个迭代器，删除这个迭代器；lower_bound()/upper_bound()，l返回大于等于x的最小的数的迭代器，u返回大于x的最小的数的迭代器

map/multimap:

insert() 插入的数是一个pair；erase()输入的参数是pair或者迭代器；find()；[]时间复杂度是O(logn)

unordered_set,unordered_map,unordere_multiset,unordere_multimap，哈希表

和上面的类似，但是增删改查的时间复杂度是O(1)，缺点是没有lower_bound()/upper_bound()，迭代器的++、–

bitset，压位

存一个1000*1000bool类型的矩阵。可以省8倍的空间

主要是为了让内存符合需要。正常的1000*1000的 bool矩阵大小=100MB，太大了，超出了题目限制，用bitset则可以变为12.5，就可以压缩大小。

bitset<100000> s;~,&,|,^,>>,<<,==,！=，【】，count()返回有多少个1，any()判断是否至少有一个1；none() 判断是否全为0，set() 把所有位置成1；set(k,v)把k位设为v

3. 搜索与图论

深搜(dfs)

栈，空间少，O(h)，

全排列：

#include
using namespace std;
int path[10],n;
int v[10],sum;
void dfs(int u){
	if(u == n){
		for(int i = 0; i < n; i ++) printf("%d ",path[i]+1);
		sum++;
		cout<>n;
	dfs(0);
	cout<

n皇后问题：

蓝桥杯算法总结_第31张图片

第一种搜索顺序：和全排列一样（一排一排放）

#include
using namespace std;
char g[20][20];
int n;
bool col[20],dg[20],udg[20];
void dfs(int u){
	if(u == n){
		for(int i=0;i>n;
	for(int i = 0;i

第二种搜索顺序：一个格子一个格子枚举

每个格子都是放或者不放两种情况

#include
using namespace std;
char g[20][20];
int n;
bool row[20],col[20],dg[20],udg[20];
void dfs(int x,int y, int s){
	if(y == n) y = 0,x++; 
	if(x == n){
		if(s == n){
			for(int i = 0;i>n;
	for(int i = 0;i

广搜(bfs)

队列，空间大O(2^h)，最短性

例题：走迷宫

#include
#include
#include
 
using namespace std;

typedef pair PII;

const int N = 110;

int g[N][N];
int d[N][N];
int n,m;
PII q[N * N];

int bfs(){
	int hh = 0,tt = 0;
	q[0] = {0,0};
	memset(d,-1,sizeof d);
	d[0][0] = 0;
	int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};
	while(hh <= tt){
		auto t = q[hh ++ ];
		for(int i= 0;i<4;i++){
			int x = t.first + dx[i] , y = t.second + dy[i];
			if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1){
				q[++tt] = {x,y};
				d[x][y] = d[t.first][t.second] + 1;//上一个位置的状态加1，其实很想dp了 
			}
		}
	}
	return 	d[n - 1][m - 1];
}
int main(){
	cin>>n>>m;
	for(int i = 0;i

树和图

图的存储方式：邻接矩阵，邻接表

蓝桥杯算法总结_第32张图片

例题：树的重心

蓝桥杯算法总结_第33张图片

#include
#include
#include
using namespace std;

const int N = 1e5+10,M = N * 2;

int h[N], e[M], ne[M],idx;
bool v[M];
int ans = N,n;
void add(int a, int b){
    e[idx] = b;//idx代表数组的位置，e[idx]代表存了哪个结点。ne[idx]代表这个结点的下个结点是谁,如5:->1->3,ne[idx] = 3,e[idx] = 1
    ne[idx] = h[a];
    h[a] = idx ++;
}

int dfs(int u){//e[i]表示i这个结点和哪个结点有关联，比如现在5:->1->3->4,代表着5和1,3,4有边
//dfs就是先找到5，然后访问5的所有关联的点，也就是h[5]连的是idx,但e[idx]=1,这里就是让j=e[idx] = 1,然后对h[1]再进行深度遍历
    v[u] = true;
    int sum = 1,res = 0;
    for(int i = h[u]; i != -1; i = ne[i]){
        int j = e[i];//res代表着当前遍历过的儿子结点中最大的数量。sum=遍历过的儿子的数量的和。
        if(!v[j]){
            int s = dfs(j);
            res = max(res,s);
            sum += s;
        }
    }//这个是儿子结点最大的那个的数量和非儿子结点中最大的。
    res = max(res,n-sum);//n-size(A)-size(B)-...size(M)-1,1是自己本身的结点。
    ans = min(ans,res);
    return sum;//dfs()返回值是sum，在dfs的过程中寻找ans和res，res是dfs(i),i这个结点去除后各部分最大的，ans是所有dfs(i)中res最小的。
    /*9
    1 2
    1 4
    1 7
    2 8
    2 5
    4 3
    4 6
    3 9
    比如4的儿子为3,6，则dfs(4)=dfs(3)+dfs(6),dfs(3)=dfs(9)+1,dfs(6)=1，这个1是sum原本设的值，很妙，因此dfs(4)=3,然后两个儿子分别为2和1
    然后res则是计算两个儿子中最大的，在循环外边再和n-sum比较，就得到了去除4这个结点时的各连通块最大值，再拿ans和res做比较，找到最小的作为ans，
    在进行操作的同时，每次dfs(4)会同时对每个子结点也做dfs，因此对于有向图，只需要dfs(i),i为根结点就能得到最小的ans了，如果不是根结点的话就dfs不全所有结点，所以一定得是根结点。
    当然对于无向图来说就没有必要了，事实上对于无向图好像并不需要再和n-sum比较。不对不对，对于无向图也是需要的，因为在dfs后，设置了v[i]把这个点注销了，那么就不存在反过来再计算的情况了，因此得再比较
    */
}


void bfs(){
    
}


int main(){
    cin>>n;
    memset(h,-1,sizeof h);
    for(int i = 0;i>a>>b;
        add(a,b);
        add(b,a);
    }
    dfs(1);
    cout<

例题：图中点的层次

蓝桥杯算法总结_第34张图片

最短路（广搜，Dijkstra）

#include
#include
#include

using namespace std;

const int N = 1e5+10; 
int h[N],e[N],ne[N],idx,n,m;
int d[N],q[N];

void add(int a,int b){
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx ++;
}

int bfs(){
	int hh = 0,tt = 0;
	q[0] = 1;
	memset(d,-1,sizeof d);
	d[1] = 0;
	while(hh<=tt){
		int t = q[hh ++ ];
		for(int i = h[t]; i != -1; i = ne[i]){
			int j = e[i];//一定得注意这里，这里是e[i]，而不是直接用i，因为i是在数组中的位置idx，而不是实际的结点，e[idx]才是idx这个位置对应的结点。 
			if(d[j] == -1){
				d[j] = d[t] + 1;
				q[ ++ tt] = j;
			}
		}
	}
	return d[n];
}

int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	for(int i = 0; i < m; i ++){
		int a,b;
		cin>>a>>b;
		add(a,b);
	}
	cout<

这里因为边的长度都是1，所以用广搜而不是Dijkstra。

例题：有向图的拓扑序列

蓝桥杯算法总结_第35张图片

计算所有点的入度，首先将入度为0的放入队列，然后如果队列不空，就弹出队头，然后将队头元素存在和其他节点的点的度-1，如果此时那个结点的度=0了，那么也把这个结点入队。直至队列为空，说明没有入度为0的结点了，那么拓扑序列就不包括这些点，且重新输出队列从0->hh对应的结点值，就是拓扑序列了。

#include
#include
#include
using namespace std;

const int N = 1e5+10;

int q[N],ne[N],e[N],idx;
int h[N],m,n,d[N];

void add(int a,int b){
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx ++;
}

bool topsort(){
	int hh = 0, tt = 0;
	for(int i =1;i <= n; i ++){
		if(d[i] == 0){
			q[tt ++ ] = i;
		}
	}
	
	while(hh <= tt ){
		int t = q[hh ++ ];
		for(int i = h[t]; i != -1; i = ne[i]){
			int j = e[i];
			d[j]--;
			if(d[j] == 0){
				q[tt ++ ] = j;
			}
		}
	}
	return tt == n;	
}

int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	for(int i =0; i < m; i ++){
		int a,b;
		cin>>a>>b;
		d[b]++;
		add(a,b);
	}
	if(topsort()){
		for(int i = 0; i < n; i++){
			cout<

最短路

①单源最短路
1.所有边权都是正数

朴素Dijkstra算法O(n^2)和堆优化版Dijkstra算法O(mlogn)，m代表边数，n代表点数

朴素Dijkstra：

①初始化距离dis[1] = 0,dis[i] = +无穷

②for i:0~n,s为当前已确定最短距离的点

③（1）先找到不在s中的点集t，然后在t中找到最短的距离的点i，（2）然后用min(i到其他点的距离加上i本身的距离，其他点的距离)更新其他点的距离，（3）并把i设为已确定的最短距离的点。

对于未优化的③（1）总共进行了n^2次，（2）进行了n次，（3）进行了m次，因此是O(n^2)

朴素

#include
#include
#include 
using namespace std;

const int N = 510;
int n,m;
int g[N][N];
int dist[N];
bool v[N];

int dijkstra(){
	memset(dist,0x3f,sizeof dist);
	dist[1] = 0;
	for(int i = 0; i < n; i ++){//n次循环 
		int t = -1;
		for(int j = 1; j <= n; j ++){//找不确定最短距离点集中距离最短的点 
			if(!v[j] && (t == -1 || dist[t] > dist[j])){
				t = j;
			}
		}
		v[t] = true;
		for(int j = 1; j <= n; j++){//用这个点去更新其他的所有点的距离， 其实可以不用更新v[j] == true的点。
			dist[j] = min(dist[j],dist[t]+g[t][j]);
		}
	}
	if(dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];	
}

int main(){
	cin>>n>>m;
	memset(g,0x3f,sizeof g);
	while(m--){
		int a, b, c;
		cin>>a>>b>>c;
		g[a][b] = min(g[a][b],c);
	}
	int t = dijkstra();
	cout<

如果把距离由原始的数组的形式写成小根堆的形式，那么对于③（1）总共就是n次，（2）是n次，但是（3）用堆更新每个点的距离是logn，然后mlogn是总次数。因此是O(mlogn)

堆优化

#include
#include
#include
#include 
using namespace std;
typedef pair PII; 
const int N = 1e5+10;
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool v[N];

void add(int a,int b,int c){
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx ++;
}
int dijkstra(){
	memset(dist,0x3f,sizeof dist);
	dist[1] = 0;
	
	priority_queue, greater> heap;//生成一个优先队列。 
	heap.push({0,1});//second是编号,first是距离。把1这个点放到队列中，且距离=0 
	while(heap.size()){
		auto t = heap.top();//找到队列的头。 
		heap.pop();//弹出头 
		int ver = t.second, distance = t.first;//记录距离最小值的距离和编号 
		if(v[ver]) continue;//如果该点是确定了最小距离的，就只弹出，但是不进行更新距离。 
        v[ver] = true;
		for(int i = h[ver]; i != -1; i = ne[i]){//如果是没有确定最小距离的。利用他来更新距离。此时的图是用邻接表来存储的。 
			int j = e[i];
			if(dist[j] > distance + w[i]){
				dist[j] = distance + w[i];
				heap.push({dist[j],j});
			}
		}
	}
	
	if(dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];	
}

int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	while(m--){
		int a, b, c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	int t = dijkstra();
	cout<
2.存在负权边

Bellman-Ford O(nm)；SPFA 一般O(m)，最坏情况下是O(nm)

如果有边数限制就只能用Bellman-Ford

为什么Bellman-Ford能应对负权边的问题？

这是由于在Dijkstra算法当中，如果存在负权边就意味着可能要推翻所有的已确定的v[ver]，那么势必会导致出现异常。

但是在Bellman-Ford算法中，是对每一条边进行遍历，所有的dist都是在实时变化的，而不存在已经确定的情况，因此可以进行负权边的最短路求解。

Bellman-Ford

①n次迭代

②每次迭代循环所有边m

再更新到各个边的最短距离前，得先备份一遍，防止串起来导致的最短距离出现问题，比如从1->2=1，从2->3=1，从1->3=3，当进行第一次循环所有边确定最短距离时，首先更新了1->2=1，此时1->3应该=3的，因为第一次循环意味着只经过了一个边，但是由于更新导致距离错乱，就是1->3=1->2+2->3=2了，但是这应该是两次循环才能达到的，类似数据库中的数据混乱，因此得进行拷贝，然后用在利用拷贝的数组在原数组上进行更新。

③然后更新到各个边的最短距离

因此时间复杂度是O(nm)

例题（有边数限制的最短路）

蓝桥杯算法总结_第36张图片

#include
#include
#include
using namespace std;

const int N = 510, M = 10010;

int n, m, k;
int dist[N], backup[N];
struct Edge{
    int a, b, w;
};
Edge edges[M];

int bellman_ford(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    for(int i = 0; i < k; i ++){
        memcpy(backup,dist ,sizeof dist);
        for(int j = 0; j < m; j ++){
            int a = edges[j].a, b = edges[j].b, w = edges[j].w ;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
    if (dist[n] > 0x3f3f3f3f / 2) return -0x3f3f3f3f;
    return dist[n];
}

int main(){
    cin>>n>>m>>k;
    for(int i = 0;i < m; i ++){
        int a,b,w;
        cin>>a>>b>>w;
        edges[i] = {a,b,w};
    }
    int t = bellman_ford();
    
    if(t == -0x3f3f3f3f) cout<<"impossible";
    else cout<

SPFA

实际上利用宽搜对Bellman-Ford进行优化，因为在Bellman-Ford中的dist[b] = min(dist[b],dist[a]+w)中只有当dist[a]变小了，dist[b]才有可能变小

优化如下：

首先将起点放入队列中，将dist[a]变小了的放入队列中，更新变小了a的所有的边，比如原本dist[5]是0x3f，由于起点1->5=3，所以dist[5]=3，因为dist[a=5]变小了，这个时候就可以把a放入队列中，然后对a能走的所有边进行一个距离更新的操作，比如5能去3,6,10，那么就对dist[3],dist[6],dist[10]进行更新操作，如果同样有变小的，如dist[3]，那么就把3进队列（当然，得看下队列中是否有3，有3就无需再进队列了），然后进行同样操作，如果队列不空，直至无dist[a]变化，且队列中没有元素了。

#include
#include
#include
#include 
using namespace std;
typedef pair PII; 
const int N = 1e5+10;
int n,m,k;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool v[N];

void add(int a,int b,int c){
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx ++;
}
int spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
	queue q;
	q.push(1);
	v[1] = true;
	while(q.size()){
	    int t = q.front();
	    q.pop();
	    v[t] = false;
	    for(int i = h[t]; i != -1; i = ne[i]){
	        int j = e[i];//e[i]是i点对应的结点,w[i]是t与i点对应结点的边权
	        if(dist[j] > dist[t] + w[i]){
	            dist[j] = dist[t] + w[i];
	            if(!v[j]){
	                q.push(j);
	                v[j] = true;
	            }
	        }
	    }
	}
	if(dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	while(m--){
		int a, b, c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	int t = spfa();
	if(t == -1) cout<<"impossible";
	else cout<

spfa判断是否存在负环

#include
#include
#include
#include 
using namespace std;
typedef pair PII; 
const int N = 1e5+10;
int n,m,k;
int h[N],e[N],ne[N],w[N],idx;
int dist[N], cnt[N];//判断负环就是在这个加个cnt表示从1-x经历了多少条边，当cnt[i]>=n时代表从1->i的边数大于等于n，由于只有n各点，最长不成环图只有n-1个点，当>=n时代表着一定成环了，一定成环也就一定成负环，否则不会成环
bool v[N];

void add(int a,int b,int c){
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx ++;
}
bool spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
	queue q;
	for(int i = 1; i <= n; i ++){
	    q.push(i);
	    v[i] = true;
	}
	while(q.size()){
	    int t = q.front();
	    q.pop();
	    v[t] = false;
	    for(int i = h[t]; i != -1; i = ne[i]){
	        int j = e[i];//e[i]是i点对应的结点,w[i]是t与i点对应结点的边权
	        if(dist[j] > dist[t] + w[i]){
	            dist[j] = dist[t] + w[i];
	            cnt[j] += 1;
	            if(cnt[j] >= n) return true;
	            if(!v[j]){
	                q.push(j);
	                v[j] = true;
	            }
	        }
	    }
	}
	return false；
}

int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	while(m--){
		int a, b, c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	if(spfa()) cout<<"Yes";
	else cout<<"No"<
②多元汇最短路

Floyd算法 O(n^3)

基于动态规划

用邻接矩阵存储所有边d[i,j]，

第一重循环k从1->n

第二重循环i从1->n

第三重循环j从1->n

更新d[i,j] = min(d[i,j],d[i,k]+d[k,j])

本来是d[m,i,j] = min(d[m-1,i,j],d[m-1,i,k]+d[m-1,k,j])

但是代表状态的m可以去掉，因此变为了d[i,j]=min(d[i,j],d[i,k]+d[k,j])

具体含义代表m状态下的i到j的最短距离=m-1状态下的i到j的最短距离或者m-1状态下的i到k的最短距离+k到j的最短距离。

#include
#include
#include

using namespace std;
const int N = 210,INF = 1e9;
int n,m,q;
int d[N][N];

void floyd(){
    for(int k = 1; k <= n; k ++){
        for(int i = 1; i <= n; i ++){
            for(int j = 1; j <= n ; j ++){
                d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
}

int main(){
    cin>>n>>m>>q;
    for(int i= 1; i <= n; i ++){
        for(int j = 1; j <= n; j ++){
            if(i == j) d[i][j] = 0;
            else d[i][j] = INF;
        }
    }
    while(m--){
        int a,b,w;
        cin>>a>>b>>w;
        d[a][b] = min(d[a][b],w);
    }
    floyd();
    while(q--){
        int a,b;
        cin>>a>>b;
        if(d[a][b] > INF / 2) cout<<"impossible"<

最小生成树

prim算法

①距离设置为无穷

②i从0到n的for循环

找到集合外距离最近的点i

用i更新其他点到集合的距离，这是因为在连通块中的点已经更新过了，因此只需要用i更新一遍就是连通块到其他点的最短距离。

v[i] = true

集合是表示已经处于连通块中的点了。

蓝桥杯算法总结_第37张图片蓝桥杯算法总结_第38张图片

#include
#include
using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n,m;
int g[N][N];
int dist[N];//此处的dist[i]代表着i点到连通块的最短距离
bool v[N];

int prim(){
    memset(dist,0x3f,sizeof dist);
    int res = 0;
    for(int i = 0;i < n; i ++){
        int t = -1;
        for(int j = 1; j <= n; j ++){
            if(!v[j] && (t == -1 || dist[t] > dist[j])) t = j;//如果是第1次循环，直接把t=1放进去。//其实我感觉可以直接把1放进去然后省略一次循环由n变为n-1次
        }
        if(i && dist[t] == INF) return INF;//如果不是第1次循环且最短距离是INF，说明这个树是不连通。
        if(i) res += dist[t];
        for(int j = 1; j <= n; j ++ ) dist[j] = min(dist[j],g[t][j]);//每次更新都是让dist[j]更新为已经连通块整体与未连通块的最小值，这也是和Dijkstra算法的区别所在，Dijkstra是起点和其他点的最小距离 
        v[t] = true;
    }
    return res;
}

int main(){
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while(m--){
        int a,b,w;
        cin>>a>>b>>w;
        g[a][b] = g[b][a] = min(g[a][b],w);
    }
    int t = prim();
    if(t == INF) cout<<"impossible"<
kruskal算法

添边的算法。

①将所有边按照权重从小到大排序 O(mlogm)，这个就是算法瓶颈，但是由于排序的系数m是比较小的，因此kruskal相对于其他的mlogn的算法来说是要快的。

②枚举每条边a-b，权重是c，如果当前a,b不连通，就将这条边加入集合中，利用并查集，总共m次就是O(m)。

#include
#include
#include
using namespace std;
const int N = 100010;
int p[N];
int n,m;

struct Edge{
    int a,b,w;
    bool operator< (const Edge &W) const{
        return w < W.w;
    }
}edges[N];

int find(int x){
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main(){
    cin>>n>>m;
    for(int i = 0; i < m; i ++){
        int a,b,w;
        cin>>a>>b>>w;
        edges[i] = {a,b,w};
    }
    sort(edges , edges + m);
    for(int i = 1;i <= n; i ++) p[i] = i;
    int res = 0, cnt = 0;
    for(int i = 0; i < m; i ++){
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        a = find(a) , b = find(b);
        if(a != b){
            p[a] = b;
            res += w;
            cnt += 1;
        }
    }
    if(cnt < n - 1) cout<<"impossible"<

二分图

判断是否为二分图：染色法O(m+n)

二分图的定义是能将顶点分为两个集合，且仅在集合间有边，集合内部是没有边的图称为二分图

具体算法：

①对于每个点利用深度优先遍历（dfs）染色

②没有出现矛盾说明是不含奇数环的，所以是二分图

出现了矛盾说明含奇数环，所以不是二分图

#include
#include
#include
using namespace std;
const int N = 100010, M = 200010;
int h[N],ne[M],e[M],idx;
int color[N];
int n, m;
void add(int a,int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

bool dfs(int u,int c){
	//注释的是我写的，现在的是y总的，我的好像出了错误，有些情况不行，通过不了,
	/* 5 5
	   5 5
	   1 2
	   1 4
	   2 3
	   2 4
	    */
//    bool flag = true;
//    color[u] = c;
//    for(int i = h[u]; i != -1; i = ne[i]){
//        int j  = e[i];
//        if(color[j] == 0) flag = dfs(j,-c);
//        else if(color[j] == c){
//            return false;
//        }
//    }
//    return flag;
	color[u] = c;
	for(int i = h[u]; i != -1; i = ne[i]){
		int j = e[i];
		if(color[j] == 0) {
			if(!dfs(j,-c)) return false;	
		}
		else if(color[j] == c) return false;
	}
	return true;
}

int main(){
    cin>>n>>m;
    memset(h,-1,sizeof h);
    while(m--){
        int a,b;
        cin>>a>>b;
        add(a,b),add(b,a);
    }
    bool flag = true;
    for(int i = 1; i <= n; i ++){
        if(!color[i]){
            if(!dfs(i, 1)){
                flag = false;
                break;
            }
        }
    }
    if(flag) cout<<"Yes"<

匈牙利算法O(mn)，实际远小于O(mn)

求二分图的最大匹配：没有两条边用同一点叫匹配，最大边个数就是最大匹配。

①从某个集合的第一个点开始选边，找第一条和另一个集合点的边，然后第二个点选边，如果第二个点只有一个边且第一个选了，那么就尝试第一个点有没有换的边，如果有，则第一个点换一条边，然后让第二个点使用这条边。

蓝桥杯算法总结_第39张图片

#include
#include
#include
using namespace std;
const int N = 510, M = 100010;
int  n1,n2,m;
int h[N],e[M],ne[M],idx;
int match[N];
bool v[N];//v[i]代表着此次过程中i以及被搜索过了，match[i]代表第i个人匹配的是谁，也就是右边的点是左边谁的匹配

void add(int a,int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

bool find(int x){
    for(int i = h[x]; i != -1; i = ne[i]){
        int j = e[i];
        if(!v[j]){//j是否搜索过，如果没有就查看j是否有匹配，如果j没有匹配，那么就让j匹配x，如果j有匹配，就查看j匹配的那个点有没有别的匹配的点可以去匹配，如果有，那么j匹配的就匹配另一个，而j就变成没有匹配的，然后j去匹配新的。如果都所有x有边的点都不能匹配，那么就返回false，res就不++。返回true的话res++；
            v[j] = true;
            if(match[j] == 0 || find(match[j])){
                match[j] = x;
                return true;
            }
        }
    }
    return false;
}

int main(){
    cin>>n1>>n2>>m;
    while(m--){
        int a,b;
        cin>>a>>b;
        add(a,b);
    }
    int res = 0;
    for(int i =1; i <= n1; i ++){
        memset(v,false,sizeof v);
        if(find(i)) res ++;
    }
    cout<

4. 数学知识

质数

质数的判定（试除法）O(sqrt(n))

bool is_prime(int x){
	if(x < 2 ) return false;
	for(int i = 2; i <= n / i; i ++)//用sqrt(n)由于这个函数运行较慢，所以不好，写成i*i <= n当n特别大的时候可能会导致i溢出 
		if(x % i == 0) return false;
	return true;
}

分解质因数法O(sqrt(n))

从小到大枚举所有数，判断是否是n的质因数，如果是，则把i和次数列出来，直到sqrt(n)

void divide(int x){
	for(int i = 2; i <= x / i; i ++){
		if(x % i == 0){// i 一定是质数，因为在1~i-1的因数已经提取出来了，那么对i来说能让x%i==0（）因数，说明i一定是质因数了。 
			int s = 0;
			while(x % i == 0){
				x /= i;
				s ++;
			}
			printf("%d %d\n",i,s);
		}
	}	
	if(x > 1) printf("%d %d\n",x,1);
}

筛法（从2到n一共有多少质数）：把不符合要求的筛出去，留下的就是符合要求的。

朴素是（n(1/2+1/3+…+1/n)nlnnnlogn）

从2开始往n挑，如果i没有被筛出去，就说明i是质数（因为i之前的数没有人的倍数是i），记录下i，同时把到n中i的倍数删除，

const int N = 1e6+10;

bool v[N];
int primes[N],cnt;

void get_prime(int n){
	for(int i = 2; i <= n; i ++){
		if(!v[i]) primes[cnt ++] = i;//如果i是false证明i不是i之前的数的倍数，说明i是质数， 就把i加入到primes数组中，同时再把i到n中，i的倍数删掉。 
		
		for(int j = i + i; j <= n; j += i ) v[i] = true;
	}
}

int main(){
	int n;
	cin>>n;
	get_primes(n);
	cout<

埃式筛法：

优化（当一个数不是质数的时候就不需要筛掉他的倍数）

原本是O(n(1/2+1/3+…+1/n))，由于只需要算质数的，根据质数定理，从1-n中有n/lnn个质数，因此为O(n(1/2+…+1/n)/lnn~nloglogn约等于n)

void get_prime(int n){
	for(int i = 2; i <= n; i ++){
		if(!v[i]){
			primes[cnt ++] = i;
			for(int j = i + i; j <= n; j += i ) v[i] = true;
			}
	}
}

线性筛法

优化（遍历比n/i小的所有已存入primes的质数，对这些质数与i的积数筛掉，直到i是某个质数的倍数时停止）

核心：n只会被最小质因子筛掉

//primes数组是从
void get_prime3(int n){
	for(int i = 2; i <= n; i ++){
		if(!v[i]) primes[cnt ++] = i;
		for(int j = 0; primes[j] <= n / i; j ++ ){
			v[primes[j] * i] = true;
			if (i % primes[j] == 0) break;
		}
	}
}

约数

（1）试除法求一个数的所有约数

#include
#include
#include 
using namespace std;

vector get_divisors(int n){
	vector res;
	
	for(int i = 1; i <= n / i ; i ++){
		if(n % i == 0){
			res.push_back(i);
			if(i != n / i) res.push_back(n / i);
		}
	}
	sort(res.begin(),res.end());
	return res;	
}

int main(){
	int n;
	cin>>n;
	while(n --){
		int x;
		cin>>x;
		vector res = get_divisors(x);
		for(auto t : res) cout<

（2）约数个数

若N = p 1 a 1 p 2 a 2 . . . p n a n p_1^{a_1}p_2^{a_2}...p_n^{a_n} p1a1​​p2a2​​...pnan​​，那么N的约数个数有 ( a 1 + 1 ) ( a 2 + 1 ) . . . ( a n + 1 ) (a_1+1)(a_2+1)...(a_n+1) (a1​+1)(a2​+1)...(an​+1)

#include
#include
#include 
using namespace std;
const int mod = 1e9+7;
typedef long long LL;
//求约数的个数
 
int main(){
	int n;
	cin>>n;
	unordered_map primes;
	while(n --){
		int x;
		cin>>x;
		for(int i = 2; i <= x / i; i ++){
			while(x % i == 0){
				x /= i;
				primes[i] ++ ;
			}
		}
		if(x > 1) primes[x] ++ ;
	}
	LL res = 1;
	for(auto prime : primes) res = res * (prime.second + 1) % mod;
	cout<

（3）约数之和

若N = p 1 a 1 p 2 a 2 . . . p n a n p_1^{a_1}p_2^{a_2}...p_n^{a_n} p1a1​​p2a2​​...pnan​​，那么N的约数之和为 ( p 1 0 + p 1 1 + . . . + p 1 a 1 ) . . . ( p n 0 + p n 1 + . . . + p n a n ) (p_1^0+p_1^1+...+p_1^{a_1})...(p_n^0+p_n^1+...+p_n^{a_n}) (p10​+p11​+...+p1a1​​)...(pn0​+pn1​+...+pnan​​)，

#include
#include
#include 
using namespace std;
const int mod = 1e9+7;
typedef long long LL;
//求约数的个数
 
int main(){
	int n;
	cin>>n;
	unordered_map primes;
	while(n --){
		int x;
		cin>>x;
		for(int i = 2; i <= x / i; i ++){
			while(x % i == 0){
				x /= i;
				primes[i] ++ ;
			}
		}
		if(x > 1) primes[x] ++ ;
	}
	LL res = 1;
	for(auto prime : primes){
		int p = prime.first , a = prime.second;	
		LL t = 1;
		while(a --) t = (t * p + 1) % mod;
		res = res * t % mod;
	}	
	cout << res << endl;
	return 0;
}

（4）欧几里得算法求最大公约数O(logn)

（a，b） = （b，a mod b）

因为a mod b = a - [a/b]*b，所以（b，a mod b） = （b，a - [a/b]*b]），如果d是a，b的最大公约数，所以d也是a - [a/b]*b]的最大公约数，所以（a，b） = （b，a mod b）

#include
using namespace std;
int n;

int name(int a,int b ){
	if(b>a) swap(a,b);
	while(a % b){
		int temp = b;
		b = a % b;
		a = b;
	}
	return b;
}
//y总的算法 
int gcd(int a, int b){
	return b ? gcd(b , a % b) : a;//b如果不是0，返回gcd(b, a % b)，如果b是0（则表示上一层的a % b == 0），则返回a（上一层的b） 
}

int main(){
	cin>>n;
	while(n -- ){
		int a , b;
		cin >> a >> b;
		int t = gcd(a,b);
		cout << t << endl;
	}
}

欧拉函数

f(n)表示1~n中与n互质的数的个数

f(6) = 2

若N = p 1 a 1 p 2 a 2 . . . p n a n p_1^{a_1}p_2^{a_2}...p_n^{a_n} p1a1​​p2a2​​...pnan​​，那么f(N) = N(1-1/p1)(1-1/p2)…(1-1/pn)

证明：容斥原理

①从1~N中去除p1,p2,…,pn的所有倍数（N-N/p1-N/p2-…-N/pn)

②加上所有pi*pj的倍数（+N/p1*p2+N/p1*p3+…N/p1*pn+…+N/pn-1*pn）

③再减去所有pi*pj*pk的倍数（-N/p1*p2*p3-…-N/pn-2*pn-1*pn)

④…n。

类比于p(AUBUC) = p(A)+P(B)+P©-p(AB)-P(AC)-P(BC)+P(ABC)

然后将上式展开就可以得到f(N) = N(1-1/p1)(1-1/p2)…(1-1/pn)

#include
#include
using namespace std;



int main(){
	int n;
	cin >> n;
	while(n -- ){
		int x;
		cin >> x;
		int res = x;
		for(int i = 2; i <= x / i; i ++ ){
			if(x % i == 0){
				res = res / i * (i - 1);
				while(x % i == 0) x /= i;
			}
		}
		if(x > 1) res = res / x * (x - 1);
		cout << res << endl;
	}
	return 0;
}

利用筛法求1~n中的数的欧拉函数

首先利用线性，如果i是质数，则i的欧拉函数等于i-1，对于现存的所有质数

如果i是某个质数的倍数，则f(i)中的是包括了这个质数的，那么i*这个质数的欧拉函数f(i * primes[j]) = primes[j] * f(i)

如果i不是所有质数的倍数，那么i * 这个质数的欧拉函数f(i * primes[j]) = primes[j] * (1 - 1/primes[j]) * f(i)

#include
#include

using namespace std;
const int N = 1e6+10;
typedef long long LL;
int n;
int primes[N], cnt;
int phi[N];
bool v[N];

LL get_eulers(int n){
	phi[1] = 1;
	for(int i = 2;i <= n; i ++){
		if(!v[i]){
			primes[cnt ++ ] = i;
			phi[i] = i - 1; 
		}
		for(int j = 0; primes[j] <= n / i; j ++){
			v[primes[j] * i] = true;
			if(i % primes[j] == 0){
				phi[primes[j] * i] = primes[j] * phi[i];
				break;
			}
			phi[primes[j] * i] = phi[i] * (primes[j] - 1);
		}
	}
	LL res = 0;
	for(int i = 1; i <= n; i ++) res += phi[i];
	return res;
}

int main(){
	cin >> n;
	cout << get_eulers(n)<

欧拉定理：若a和n互质，则有 a f ( n ) m o d n = 1 a^{f(n)} mod n = 1 af(n)modn=1

证明：n中所有与n互质的数为a1…af(n)共f(n)个，那么a*a,…,a*an与n互质，且a*ai%n互不相同，而小于n且与n互为质数的数总共只有f(n)个，所以 a f ( n ) a 1 . . . a f ( n ) m o d n 一定且只能等于 a 1 . . . a f ( n ) m o d n a^{f(n)}a_1...a_{f(n)} mod n 一定且只能等于 a_1...a_{f(n)} mod n af(n)a1​...af(n)​modn一定且只能等于a1​...af(n)​modn

同时约掉后面的，则 a f ( n ) m o d n = 1 a^{f(n)} mod n = 1 af(n)modn=1

快速幂

是一种能够快速O(logk)求出 a k m o d p a^k mod p akmodp的算法。当k很大的时候可以使用，如范围在1-10^9时，因为普通的算法在O(k)超过了一千万了，因此不行。

思想：

首先预处理出来 a 2 0 , a 2 1 , . . . , a 2 l o g k a^{2^0},a^{2^1},...,a^{2^{logk}} a20,a21,...,a2logk%p的结果

然后将a^k用上述表示后乘起来再做模运算即可。而 a 2 0 , a 2 1 , . . . , a 2 l o g k a^{2^0},a^{2^1},...,a^{2^{logk}} a20,a21,...,a2logk很好处理得到，后一位是前一位的平方。 a 2 l o g k = ( a 2 l o g k − 1 ) 2 a^{2^{logk}}=(a^{2^{logk-1}})^2 a2logk=(a2logk−1)2，因此预处理只需要logk的时间，转化为k转化为2进制也是logk的时间，因此整个算法的复杂度就是O(logk)

#include
#include
#include
 
using namespace std;
typedef long long LL;

//a^k % p
int qmi(int a, int k, int p){
	int res = 1;
	while(k){//如果k不等于0，如果当前k的二进制为1，则让现在的模了剩下的数 = 之前模了剩下*当前位置模了剩下的数再取模 
		if(k % 2) res = (LL) res * a % p;
		k /= 2;//二进制进一位 
		a = (LL) a * a % p;//上一个模了剩下的数的平方再 取模 
	}
	return res;
}

int main(){
	int n;
	scanf("%d",&n);	
	while(n -- ){
		int a, k, p;
		scanf("%d %d %d", &a, &k, &p);
		printf("%d\n",qmi(a, k, p)); 
	}
	return 0;	
}

快速幂求逆元

蓝桥杯算法总结_第40张图片

给定一个ai找到逆元x使得ai*x=1(mod p)

由于此处的p是质数，所以根据欧拉定理中的费马定理，ai^(p-1) % p = 1，所以x=a^(p-2)，所以就是输入一个数a和模数p，然后求a的p-2次幂mod p，当b是p的倍数的时候，无解。

#include
#include
#include
 
using namespace std;
typedef long long LL;

//a^k % p
int qmi(int a, int k, int p){
	int res = 1;
	while(k){
		if(k % 2) res = (LL) res * a % p;
		k /= 2;
		a = (LL) a * a % p;
	}
	return res;
}

int main(){
	int n;
	scanf("%d",&n);	
	while(n -- ){
		int a, k, p;
		scanf("%d %d", &a, &p);
		int res = qmi(a, p - 2, p);
		if(a % p) printf("%d\n",res); 
		else printf("impossible\n");
	}
	return 0;	
}

扩展欧几里得算法

裴蜀定理

有一对正整数a，b，那么一定存在非零整数x，y，使得ax+by=gcd（a,b）

核心：通过递归最后一层得到当时的x和y并传回到倒数第二层，对倒数第二层确定好对应的系数位置，然后对第二层时的等式进行整理，更新x和y，此时可以看到只需更新y。

蓝桥杯算法总结_第41张图片

当欧几里得算法return的时候，b=0，return a，也就是到了gcd(a,0)=a，此时ax+by=gcd(a,0)，即x=1，y=0，然后递归回上一层时，由于是gcd(b,a % b)传进去的，所以此时是b为a，a % b = 0，所以返回上一层就是y=1，x=0，也就是对应的x，y每返回一层得交换，因此int d = exgcd(b,a%b,y,x)，那么在倒数第二层的情况是by+a%bx = d，也就是by+(a-[a/b]*b)x = d，整理得ax+b(y-[a/b]*x) = d，则x不用变，y变为y-[a/b]*x

#include
using namespace std;

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

int main(){
	int n;
	scanf("%d",&n);
	while(n --){
		int a,b,x,y;
		scanf("%d%d",&a,&b);
		exgcd(a,b,x,y);
		printf("%d %d\n",x,y);
	}
	return 0;
}

例题：线性同余方程（当bi为1，且mi为质数时，就变成了快速幂求逆元了，这里是普遍情况下的求法）

蓝桥杯算法总结_第42张图片

#include
using namespace std;
typedef long long LL;

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

int main(){
	int n;
	scanf("%d",&n);
	while(n --){
		int a,b,m;
		scanf("%d%d%d",&a,&b,&m);
		int x,y;
		int d = exgcd(a,m,x,y);//扩展和原的返回值都是前两个值的最大公因数，只是扩展欧几里得算法还拓展了返回x,y，使得ax+by = d ,d就是最大公因数。 
		if(b % d) printf("impossible\n");
		else printf("%d %d\n",(LL) x * (b / d) % m);//x * b/gcd(a,m) % m，因为b可能是gcd的倍数，所以用x*b/gcd 才是ax+my = d的解，还得mod m 
	}
	return 0;
}

中国剩余定理

若存在 m 1 , m 2 , . . . , m n 两两互质 m_1,m_2,...,m_n两两互质 m1​,m2​,...,mn​两两互质，对于方程组 x = a i ( m o d   m i ) , i = 1 , 2 , . . . , n x=a_i(mod\space{}m_i),i=1,2,...,n x=ai​(mod mi​),i=1,2,...,n，有解 x = a 1 M 1 M 1 − 1 + a 2 M 2 M 2 − 1 + . . . + M n M n − 1 x=a_1M_1M_1^{-1}+a_2M_2M_2^{-1}+...+M_nM_n^{-1} x=a1​M1​M1−1​+a2​M2​M2−1​+...+Mn​Mn−1​，其中 M = m 1 m 2 . . . m n M = m_1m_2...m_n M=m1​m2​...mn​， M i = M m i , M i − 1 表示 M i 模 m i 的逆 M_i=\frac{M}{m_i},M_i^{-1}表示M_i模m_i的逆 Mi​=mi​M​,Mi−1​表示Mi​模mi​的逆， M i − 1 M_i^{-1} Mi−1​可以用扩展欧几里得算法求

高斯消元

蓝桥杯算法总结_第43张图片

求组合数

（1）十万组询问求 C a b C_a^b Cab​，1

如果直接进行运算的话是100000X2000=2^ 8超过了1^8所以会超时，因此不能用这个方法。

最终选择先预处理出来所有的 C a b C_a^b Cab​，然后进行n次询问，由于预处理所有的 C a b C_a^b Cab​，只需要2000^ 2次（两层for循环，同时 C a b = C a − 1 b + C a − 1 b − 1 C_a^b=C_{a-1}^b+C_{a-1}^{b-1} Cab​=Ca−1b​+Ca−1b−1​），因此是4*10^6，可以解决。

#include
using namespace std;

const int N = 2010, mod = 1e9 + 7;
int e[N][N];

void init(){
	for(int i = 0; i < N; i ++)
		for(int j = 0; j <= i; j ++ )
			if(!j) e[i][j] = 1;
			else e[i][j] = (e[i - 1][j - 1] + e[i - 1][j]) % mod;

}

int main(){
	init();
	int n;
	scanf("%d",&n);
	while(n -- ){
		int a, b;
		scanf("%d%d",&a,&b);
		cout<

（2）a，b较大为10000时

首先预处理出i!和(i!)的逆元，然后利用 C a b = a ! b ! ( a − b ) ! C_a^b=\frac{a!}{b!(a-b)!} Cab​=b!(a−b)!a!​，

#include
using namespace std;

typedef long long LL;

const int N = 1e5 + 10, mod = 1e9 + 7;
int fact[N], infact[N];//逆元用快速幂来求。 
//首先预处理出i!%mod以及(i!)%mod的逆元。 
//为什么要用逆元的原因是(i mod p)/(b mod p) 不等于i/b 

int qmi(int a,int k,int p){
	int res = 1;
	while(k){
		if(k % 2) res = (LL) res * a % p;
		a = (LL) a * a % p;
		k = k / 2;
	}
	return res;
}

int main(){
	fact[0] = infact[0] = 1;
	for(int i = 1; i <= N; i ++){//次数qmi的意思是i的逆元，由于mod为质数，所以能用这种方法，否则需要找一个大于100010的质数去做。 
		fact[i] = (LL)(fact[i - 1] * i) % mod;
		infact[i] = (LL)infact[i - 1] * qmi(i,mod - 2, mod) % mod;	
	}
	int n;
	scanf("%d",&n);
	while(n --){
		int a,b;
		scanf("%d%d",&a,&b);
		cout << (LL) fact[a] * infact[b] % mod * infact[a - b] % mod << endl;
	}	
	return 0;
}

（3）a，b很大10^ 18，但是只询问了20组，1

蓝桥杯算法总结_第44张图片

卢卡斯定理： C a b = C a   m o d   p b   m o d   p C a / p b / p C_a^b=C_{a\space mod\space p}^{b\space mod \space p}C_{a/p}^{b/p} Cab​=Ca mod pb mod p​Ca/pb/p​，时间复杂度为 l o g p N   p l o g p = p l o g N l o g p log_pN\space plogp=plogNlogp logp​N plogp=plogNlogp，

证明：p为质数，对于a来说存在 a = a 0 p 0 + . . . + a k p k a=a_0p^0+...+a_kp^k a=a0​p0+...+ak​pk，对b来说存在 b = b 0 p 0 + . . . + b k p k b = b_0p^0+...+b_kp^k b=b0​p0+...+bk​pk，由于 ( 1 + x ) a = ( 1 + x ) a 0 . . . ( 1 + x ) a k (1+x)^a=(1+x)^{a_0}...(1+x)^{a_k} (1+x)a=(1+x)a0​...(1+x)ak​，对于左边来说xb的系数则为$C_a^b$，而右边xb的系数则为 C a 0 b 0 . . . C a k b k C_{a_0}^{b_0}...C_{a_k}^{b_k} Ca0​b0​​...Cak​bk​​，因此卢卡斯定理得证

#include
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
int p;

int qmi(int a,int k){
	int res = 1;
	while(k){
		if(k % 2) res = res * a % p;
		k /= 2;
		a = (LL) a * a % p;
	}
	return res;
}

int C(int a,int b){
	int res = 1;
	for(int i = 1, j = a; i <= b; i ++, j -- ){
		res = (LL) res * j % p;
		res = (LL) res * qmi(i, p - 2) % p;
	}
	return res;
}

int lucas(LL a, LL b){
	if(a < p && b < p) return C(a % p, b % p);
	return (LL)C(a % p, b % p) * lucas(a / p, b / p) % p;
	
}
int main(){
	int n;
	cin >> n;
	while(n -- ){
		LL a, b;
		cin >> a >> b >> p;
		cout << lucas(a, b) << endl; 
	}
	return 0;
}

（4）a，b不是很大，但结果不%任何数，要高精度。

思路：

①分解质因数

C a b = a ! b ! ( a − b ) ! C_a^b=\frac{a!}{b!(a-b)!} Cab​=b!(a−b)!a!​对上面的进行分解质因数，对下面的分解质因数，如果质因数p在上面有就是+1，如果在下面有就是-1。最终得到一个质因数个数的数组。

②高精度乘法。

#include
#include
using namespace std;
const int N = 5010;

int primes[N],cnt;
int sum[N];
bool v[N];

void get_primes(int n){
	for(int i = 2; i <= n; i ++){
		if(!v[i]) primes[cnt ++] = i;
		for(int j = 0; primes[j] <= n / i ;j ++){
			v[i * primes[j]] = true;
			if(i % primes[j] == 0) break;
		}
	}
}

int get(int n,int p){
	int res = 0;
	while(n){
		res += n / p;
		n /= p;
	}
	return res;
}

vector mul(vector a,int b){
	vector e;
	int t = 0;
	for(int i = 0; i < a.size(); i ++){
		t = t + a[i] * b;
		e.push_back(t % 10);
		t /= 10;
	}
	while(t){
		e.push_back(t % 10);
		t /= 10; 
	}
	return e;
}

int main(){
	int a,b;
	cin >> a >> b;
	
	get_primes(a);
	
	for(int i = 0; i < cnt; i ++){
		int p = primes[i];
		sum[i] = get(a, p) - get(b, p) - get(a - b, p);
	}
	for(int i = 0; i < cnt; i ++){
		cout< res;
	res.push_back(1);
	
	for(int i = 0; i < cnt; i ++){
		for(int j = 0; j = 0; i --){
		cout<

Catalan数(卡特兰数)

蓝桥杯算法总结_第45张图片

蓝桥杯算法总结_第46张图片

6个1，6个0，从(0,0)到(6,6)的路径数有 C 12 6 C_{12}^6 C126​条，不符合规矩的就是触碰到了红线的路径，而触摸到了红线的路径就等于从(0,0)到(5,7)的路径，因此方案数= C 12 6 − C 12 5 C_{12}^6-C_{12}^5 C126​−C125​

，对应本题的方案数即为 C 2 n n − C 2 n n − 1 = ( 2 n ) ! n ! n ! − ( 2 n ) ! ( n − 1 ) ! ( n + 1 ) ! = 1 n + 1 C 2 n n C_{2n}^n-C_{2n}^{n-1}=\frac{(2n)!}{n!n!}-\frac{(2n)!}{(n-1)!(n+1)!}=\frac{1}{n+1}C_{2n}^{n} C2nn​−C2nn−1​=n!n!(2n)!​−(n−1)!(n+1)!(2n)!​=n+11​C2nn​

#include
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;

int n;

int qmi(int a, int k, int p){
	int res = 1;
	while(k){
		if(k % 2) res = (LL) res * a % p;
		a = (LL) a * a % p;
		k /= 2;
	}
	return res;
}

int C(int a, int b){
	int res = 1;
	for(int i = 1, j = a; i <= b; j --, i ++){
		res = (LL) res * j % mod;
		res = (LL) res * qmi(i, mod - 2, mod) % mod;
	}
	return res;
}

int main(){
	cin >> n;
	int res = (LL)C(2 * n, n) / (n + 1) % mod;
	cout<

容斥原理

内容：对集合 S 1 , S 2 , . . . , S n S_1,S_2,...,S_n S1​,S2​,...,Sn​， S 1 ∪ S 2 ∪ . . . ∪ S n = S 1 + S 2 + . . . + S n − S 1 ∩ S 2 − S 1 ∩ S 3 − . . . − S 1 ∩ S n − . . . − S n − 1 ∩ S n + S 1 ∩ S 2 ∩ S 3 . . . + ( − 1 ) n − 1 S 1 ∩ S 2 ∩ . . . ∩ S n S_1∪S_2∪...∪S_n=\\S_1+S_2+...+S_n\\-S_1∩S_2-S_1∩S_3-...-S_1∩S_n-...-S_{n-1}∩S_n\\+S_1∩S_2∩S_3...+(-1)^{n-1}S_1∩S_2∩...∩S_n S1​∪S2​∪...∪Sn​=S1​+S2​+...+Sn​−S1​∩S2​−S1​∩S3​−...−S1​∩Sn​−...−Sn−1​∩Sn​+S1​∩S2​∩S3​...+(−1)n−1S1​∩S2​∩...∩Sn​

共2^n-1项。

例题：能被整除的数

蓝桥杯算法总结_第47张图片

可以看到n的范围在10^9，如果用循环一定是会超时的。因此选择使用容斥定理

素数i的集合 S i = i , 2 i , . . . , n i S_i={i,2i,...,ni} Si​=i,2i,...,ni

对所有的素数p_i的集合利用容斥原理求并集个数即为能被整除的数的个数，时间复杂度为(2m)此处m在16以内，因此最大为65536。可以接受。而集合的个数是[n/p]，有多个素数的倍数就是[n/(p1p2…pj)]，求集合的个数是O(m)的，最终所有的时间复杂度是O(m*2m)=220=106，可以接受的。

#include
using namespace std;
typedef long long LL; 
const int N = 20;
int n, m;
int p[N];


int main(){
	cin >> n >> m;
	for(int i = 0; i < m; i ++) cin >> p[i];
	int res = 0;
	for(int i = 1; i < 1 << m; i ++){//由于是从m个素数中选择任意个，因此有2^n-1种情况 ，利用位运算来选择要选的素数。如i=1，就是00001，只选择第一个素数，当i=2的时候就是00010，只选择第二个素数，当i=5的时候就是00101，选择第三个和第一个素数，而且根据1的个数来确定是加还是－，如果是偶数就是-，奇数就是+。 
		int t = 1, cnt = 0;
		for(int j = 0; j < m; j ++){
			if(i >> j & 1){
				cnt ++;
				if((LL)t * p[j] > n){
					t = -1;
					break;
				}
				t *= p[j];
			}
		}
		if(t != -1){
			if(cnt % 2) res += n / t;
			else res -= n / t;
		}
	}
	cout << res << endl;
	return 0;
}

5. 动态规划

做DP问题需要考虑的：

蓝桥杯算法总结_第48张图片

两个方面，一是用什么状态表示（一维，二维，…，n维数组），表示完后要考虑两个问题，一个是这个集合的含义，一个是这个表示的属性，如i个物品在体积为j的情况下的最大值。二是状态计算（从上一个状态到下一个状态的变化是什么，也就是状态转移方程）。

1. 背包问题

0 1背包（每件物品只能用一次）

#include
using namespace std;

const int N = 1010;
int v[N], w[N];
int dp[N][N];
int n, V;
int f[N]; 

int main(){
	cin >> n >> V ;
	for(int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
	for(int i = 1; i <= n; i ++){
		//未优化的二维的dp算法 
		for(int j = 1; j <= V; j ++){
			dp[i][j] = dp[i - 1][j];
			if(j >= v[i]) dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
		}
		//优化后的一维的DP算法
		//首先把i去除，从二维的可以看到 
		for(int j = V; j >= v[i]; j --){
//			dp[j] = dp[j] 但是由于这个式子恒成立，所以去除。
			f[j] = max(f[j],f[j - v[i]] + w[i]);//这个式子直接去除了i轴，但是直接去除和之前显然是不等价的，因为dp[i-1]变成里dp[i]，但是如果是从后往前更新，那么dp[i]中存的就是上一次的dp[i-1]，因此将for循环改为从后往前就可以用直接删了i轴的维度了。 
		} 
	} 
	cout << dp[n][V] << endl;
	cout << f[V] << endl;
	return 0;
}

完全背包（每件物品有无限个）

#include
using namespace std;
const int N = 1010;
int dp[N][N];
int p[N];
int f[N][N];
int v[N], w[N];
int n, m;

int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    for(int i = 1; i <= n; i ++){
        int k = 0;
        for(int j = 0; j <= m; j ++){
            //未优化的算法，此时由于多了一层k循环，这个循环最大可能是N的，因此最终时间复杂度为O(n^3) = 1e9会超时。因此想办法把k的循环去除，那么如何优化掉k呢
            f[i][j] = f[i - 1][j];
            //之前的是没有变化的，从这个k的for循环中可以看到，我们是找到第i-1个状态下j,j-v[i],j-2*v[i],...j-k*v[i]中最大的，并且让f[i][j]=这个最大值
            //那么f[i][j-v[i]]呢，由上述的表达式可以知道f[i][j-v[i]]是在j-v[i],j-2*v[i],...j-(k-1)*v[i]中最大的，那么f[i][j]与f[i][j-v[i]]的区别就是没有把f[i-1][j]和之前的比较得出最大值，而由于f[i][j-v[i]]就是之前那些值中的最大值，那么就只需要把f[i-1][j]和f[i][j-v[i]]比较即可得到对于f[i][j]来说的之前的最大值了
            
            for(int k = 0; j - k * v[i] >= 0; k ++){
                f[i][j] = max(f[i][j],f[i - 1][j - k * v[i]]+k * w[i]);
            }
            //优化后的算法
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i]) dp[i][j] = max(dp[i][j],dp[i][j - v[i]] + w[i]);
            //还能优化为一维的吗？可以看到当i轴去除后，就变成了
            if(j >= v[i]) p[j] = max(p[j],p[j - v[i]] + w[i]);
        }
    }
    cout << p[m] << endl;
    return 0;
}

可以看到优化后的01背包问题和完全背包问题只有顺序有不同的了，01背包问题的j是从后往前，而完全背包问题是从前往后，为什么顺序不同呢？

我认为01背包问题从后往前是因为只需要-一个v[i]，从后往前就能够-了，且由于要利用现有的一维数组保留i-1个物品时的状态。而从前往后则会让后来的串联起来，导致后面的改变不是在i-1个物品时的状态了，因此需要从后往前。

而完全背包问题是需要将前面改为了i个物品状态的时候再更新，也就是由于数量是无限的所以需要串联，因此导致后面的改变需要在前面更新的基础上更新，因此需要从前往后走。

多重背包问题（每件物品的个数不一样）

多重背包问题和完全背包问题很像，但是由于数量是有限的，因此在挑选最大值的时候是从j，j-v[i]，…，j-num[i]*v[i]这样一个范围挑选，类似于滑动窗口求最大值。

朴素做法：（当n，V和S不是很大的时候可以用，100左右，O(nVS）

#include
using namespace std;
const int N = 110;
int n, V;
int v[N], w[N], s[N];
int dp[N][N];
int main(){
    cin >> n >> V;
    for(int i = 1; i <= n; i ++) cin >> v[i] >> w[i] >> s[i];
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= V; j ++){
            dp[i][j] = dp[i - 1][j];
            //朴素做法，在完全背包问题中加入一个数量小于s[i]的限制即可
            for(int k = 0; j - k * v[i] >= 0 && k <= s[i]; k ++){
                dp[i][j] = max(dp[i][j],dp[i - 1][j - k * v[i]]+ k * w[i]);
            }
        }
    }
    cout << dp[n][V] << endl;
    return 0;
}

优化算法（将第i个物品s[i]个数量分解成logsi个物品，现在对于这些物品就是01背包问题了，而01背包问题的复杂度为O(nV)，现在的V没变，但是n变为了n*logs个，因此优化后的算法复杂度为O(nVlogs)，当n=1000,s,v=2000的时候就是1000*2000*log2000 = 2*10^7，可以接受）

#include
using namespace std;
const int N = 11000, M = 2010;//为什么N开到11000是因为原来的n有1000个，而log2000的上取整是11，因此11000才不会发生越界
int n, V;
int v[N], w[N], s[N];
int dp[N];
int main(){
    cin >> n >> V;
    int cnt = 0;
    //在读入vws的时候就直接把这个转换为01背包问题，那么cnt就是新的数量n。
    //为什么能这么转换是因为将一个数量s的物品转换为n组数量为a[i]的物品后，对这些物品的选择与否能够数量为s的物品选择任意个的结果。
    //如s = 10,则转化为由个数1,2,4,3变成的新的四组物品，这四组物品的vi分别为v,2v,4v,3v，wi分别为w,2w,4w,3w
    //而新的四组物品的01背包问题，能够组成原始多重背包问题j~j-10v+10w的最大值
    //比如7的时候的最大值，可以选择第1、2、3组,就可以构成7,
    //比如5的时候的最大值，可以选择第1、3组。
    //为什么任意的s能够由一个二进制的组构成，是因为第一项能够构成0~1，加上第二项能够构成2~3，也就是0~3,加上第三项能够构成4~7,也就是0~7，加上第k项能够构成c~c+2^k-1=s,而c一定是小于等于2^k，否则能够把c分解成2^k+c1，此时c1作为新的c。而c小于等于2^k,而除开c之前的数能够构成2^k-1，因此能够构成0~s的任意一个数（类似用二进制优化）
    for(int i = 1; i <= n; i ++){
        int a, b, s;
        cin >> a >>b >> s;
        int k = 1;
        while(k <= s){
            cnt ++ ;
            v[cnt] = a * k;
            w[cnt] = b * k;
            s -= k;
            k *= 2;
        }
        if(s > 0){
            cnt ++ ;
            v[cnt] = a * s;
            w[cnt] = b * s;
        }
    }
    n = cnt;
    for(int i = 1; i <= n; i ++){
        for(int j = V; j >= v[i]; j --){
            dp[j] = max(dp[j],dp[j - v[i]] + w[i]);
        }
    }
    cout << dp[V] << endl;
    return 0;
}

分组背包问题（有N组物品，每组物品有若干个，每组物品只能选一个）

蓝桥杯算法总结_第49张图片

核心思想：

和01背包问题一样，对于每一组i的物品k，在体积j大于v[i][k]的时候，对每一个该组i的物品k都进行最大值的判断，找到最大值，将值赋予f[j]。比如f[1-10] = 1-10，现在有第二组一个物品k=1为v=2，w=3，那么f[10] = max(f[10],f[8]+3) = 11，第二组第二个物品为k=2，v=2,w=5，那么就有f[10] = max(f[10],f[8]+5) = 13，这样子来更新。

#include
using namespace std;
const int N = 110;
int n, V;
int v[N][N], w[N][N], s[N];
int dp[N];

int main(){
    cin >> n >> V;
    for(int i = 1; i <= n; i ++){
        cin >> s[i];
        for(int j = 1; j <= s[i]; j ++){
            cin >> v[i][j] >> w[i][j];
        }
    }
    for(int i = 1; i <= n; i ++){
        for(int j = V; j >= 0; j --){
            for(int k = 1; k <= s[i]; k ++){
                if(v[i][k] <= j){
                    dp[j] = max(dp[j],dp[j - v[i][k]] + w[i][k]);
                }
            }
        }
    }
    cout << dp[V] << endl;
    return 0;
}

2. 线性DP

数字三角形：

#include
using namespace std;

const int N = 510, INF = 1e9;
int g[N][N];
int dp[N][N];
int n;

int main(){
    cin >> n;
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= i; j ++){
            cin >> g[i][j];
        }
    }
    
    for(int i = 0; i <= n; i ++){
        for(int j = 0; j <= i + 1; j ++){
            dp[i][j] = - INF;
        }
    }
    
    dp[1][1] = g[1][1];
    
    for(int i = 2; i <= n; i ++){
        for(int j = 1; j <= i ; j ++){
            dp[i][j] = max(dp[i - 1][j - 1] , dp[i - 1][j]) + g[i][j];
        }
    }


    int res = - INF;
    for(int i = 1; i <= n; i ++){
        res = max(res, dp[n][i]);
    }
    cout << res << endl;
    return 0;
}

最长上升子序列（输出了最长序列）

蓝桥杯算法总结_第50张图片

#include
#include
using namespace std;

const int N = 1010;
int n;
int a[N], dp[N], m[N];

int main(){
	cin >> n;
	memset(m,-1,sizeof m);
	for(int i = 1; i <= n; i ++) cin >> a[i];
	for(int i = 1; i <= n; i ++){
		dp[i] = 1;
		for(int j = 1; j < i; j ++){
			if(a[j] < a[i]){
			    if(dp[i] < dp[j] + 1){
			        m[i] = j;
			        dp[i] = dp[j] + 1;
			    }
			}
		}
	}	
	int res = 0, index = -1;
	for(int i = 1; i <= n; i ++){
	    if(res < dp[i]){
	        res = dp[i];
	        index = i;
	    }
	}
	cout << res << endl;
	for(int i = index; i != -1; i = m[i]){
	    cout << a[i] << " ";
	}
	cout << endl;
	
}

最长上升子序列（数据量更大的时候）

分析序列的性质，可以发现，如果设q[i]为子序列长度为i时的值，有q[j]>q[i]当j>i时恒成立，而当新进入的一个数字，如果这个数字比q[j]大而比q[j+1]小，那么子序列长度为j+1的子序列的值就应该是这个新进入的数字的值，比如3，4，1，2，6。q[1] = 3，q[2] = 4，而现在来了一个1，进行比较发现12>q[1]，因此q[2] = 2，对于新数字6来说，6>q[2]，因此q[3] = 6，而最长子序列就是数组q的长度3。

#include
using namespace std;

const int N = 1e5 + 10;

int a[N], q[N];
int n;
int dp[N];

int main(){
	cin >> n;
	for(int i = 0; i < n; i ++) cin >> a[i];
	int len = 0;
	q[0] = - 2e9;
	for(int i = 0; i < n; i ++){
		int l = 0, r = len;
		while(l < r){
			int mid = l + r + 1>> 1;
			if(q[mid] < a[i]) l = mid;
			else r = mid - 1;
		}
		len = max(len, r + 1);
		q[r + 1] = a[i];
	}
	cout << len << endl;
	return 0;
}

最长公共子序列

蓝桥杯算法总结_第51张图片

蓝桥杯算法总结_第52张图片

#include
using namespace std;

const int N = 1010;

char a[N], b[N];
int n, m;
int dp[N][N];

int main(){
    cin >> n >> m;
    scanf("%s%s",a + 1, b + 1);
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            dp[i][j] = max(dp[i - 1][j],dp[i][j - 1]);
            if(a[i] == b[j]) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
        }
    }
    cout << dp[n][m] <

编辑距离

image-20230203211606791

3. 区间DP

石子合并

#include
#include

using namespace std;

const int N = 5010, INF = 1e9;

int a[N], s[N];
int dp[N][N];//从i到j堆石子合并的代价
int n;

int main(){
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i];
    for(int i = 1; i <= n; i ++) s[i] = s[i-1] + a[i];
    
    for(int i = 0; i <= n; i ++){
        for(int j = 0; j <= n; j ++){
            dp[i][j] = INF;
            if(i >= j) dp[i][j] = 0;
        }
    }
    //不用len来做。
    // for(int i = n; i >= 1; i --){//注意i得从n开始，因为dp[i][j] = dp[i][k] + dp[k][j]总是需要先用到后面的，因此如果是从前面开始，用到dp[k][j]时，dp[k][j]还是INF,会导致最终的答案偏大
    //     for(int j = i + 1; j <= n; j ++){
    //         for(int k = i; k < j; k ++){
    //             dp[i][j] = min(dp[i][j],dp[i][k] + dp[k + 1][j] + s[j] - s[i - 1]);
    //         }
    //     }
    // }
    //用len来做
    for(int len = 1; len <= n; len ++){
        for(int i = 1; i + len - 1 <= n; i ++){
            int j = i + len - 1;
            if(j == i) dp[i][j] = 0;
            else{
                for(int k = i; k <= j; k ++){
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s[j] - s[i - 1]);
                }
            }
        }
    }
    // for(int i = 1; i <= n; i ++){
    //     for(int j = 1; j <= n; j ++){
    //         cout << dp[i][j] << " ";
    //     }
    //     cout << endl;
    // }
    
    cout<

4. 计数类DP

整数划分

蓝桥杯算法总结_第53张图片

蓝桥杯算法总结_第54张图片

#include
using namespace std;
const int N = 1010, mod = 1e9 + 7;

int n;
int dp[N][N]; 

int main(){
	cin >> n;
	dp[0][0] = 1;
	for(int i = 1; i <= n; i ++){
		for(int j = 1; j <= i; j ++){
			dp[i][j] = dp[i - 1][j - 1] + dp[i - j][j] % mod;
		}
	}
	int res = 0;
	for(int i = 1; i <= n; i ++) res += dp[n][i] % mod;
	cout << res << endl;
	return 0;
}

5. 数位统计DP

计数问题

对于解决某个区间的问题，我们经常用0n的情况-0m的情况，以获得n~m的情况，类似于前缀和的思想

蓝桥杯算法总结_第55张图片

#include
#include
#include
#include

using namespace std;


int count(int n, int x){
    if(!n) return 0;
    
    vector num;
    while(n){
        num.push_back(n % 10);
        n /= 10;
    }
    n = num.size();
    int res = 0;
    for(int i = 0; i < n; i ++){
        //依次统计各个数位上的x的个数，总和即为所有x的个数。
        if(i < n - 1){
            //前面有数字且在000-abc-1的情况
            int sum = 0;
            
            for(int j = n - 1; j > i; j --){
                sum = sum * 10 + num[j];
            }
            // cout << "sum = " << sum << endl;
            if(x) res += sum * pow(10, i);
            else res += (sum - 1) * pow(10, i);//由于没有前导0，所以如果x是0的话需要-1.
            
            // cout << "res = " << res << endl;
            //计算后面的情况，即前面数字为abc时，第i个数如果==x，那么还要加上efg + 1种情况，如果第i个数>x，则后面的efg为任何数都可以就是pow(10,3)中情况。，如果第i个数= 0; j --){
                sum = sum * 10 + num[j];
            }
            if(num[i] == x) res += sum + 1;
            else if(num[i] > x) res += pow(10, i);
        }
        else{
            //对于前面没有数字的时候，就没有000-abc-1的情况，直接计算后面的情况，如果第i个数==x，但是x==0，说明最前面的数是0，这是不符合规范的，所以这个和之前的比较出现问题的地方在x==0,因此在if判断中加上x!=0即可。其他的数是没有影响的，如果是0就无情况就行。
            int sum = 0;
        
            for(int j = i - 1; j >= 0; j --){
                sum = sum * 10 + num[j];
            }
            
            if(num[i] == x && x != 0) res += sum + 1;
            else if(num[i] > x && x != 0) res += pow(10,i);
        }
    }
    return res;
}


int force_count(int n, int x){
    int res = 0;
    for(int i = 1; i <= n; i ++){
        for(int j = i; j; j /= 10){
            if(j % 10 == x)
                res ++;
        }
    }
    return res;
}

int main(){
    int n, m;
    while(cin >> n >> m, m || n){
        if(n > m) swap(n,m);
        // cout << count(10,0);
        for(int i = 0; i <= 9; i ++) cout << count(m, i) - count(n - 1, i) << " ";
        cout << endl;
    }
    
    
}

6. 状态压缩DP

蓝桥杯算法总结_第56张图片

蓝桥杯算法总结_第57张图片为什么叫状态压缩DP是因为这里的j和k是10进制的数，但是被我们看成是2进制的形式。用二进制的形式来表示是否伸出来的那个状态如10011，用整数表示某个状态，因此叫状态压缩。

#include
#include
using namespace std;

const int N = 12, M = 1 << N;

int n, m;
long long dp[N][M];
bool v[M];

int main(){
    int n, m;
    while(cin >> n >> m , n || m){
        memset(dp, 0, sizeof dp);
        //先预处理出来哪些j和k是可以匹配上的。
        for(int i = 0; i < 1 << n; i ++){
            v[i] = true;
            int cnt = 0;//连续0的个数。
            for(int j = 0; j < n; j ++){
                if(i >> j & 1){//如果i的二进制表示中为1，则判断之前的0的个数有多少个，如果是奇数个，则v[i]=false，也就是i不合法。
                    if(cnt & 1) v[i] = false;
                    cnt = 0;//如果是偶数个就令cnt=0，因为从下一个开始又要重新计数了。
                }
                else cnt ++;//如果i的二进制当前不为1，则记连续的0个数++。
            }
            if(cnt & 1) v[i] = false;//由于最后还有可能剩下一连串的0的个数，因此还要判断剩下的0是否是偶数。
        }
        //上面预处理完了以后，下面就是dp的过程了。
        dp[0][0] = 1;
        for(int i = 1; i <= m; i ++){//i从1到m，代表了从第一列到第m列
            for(int j = 0; j < 1 << n; j ++){//这里是第i列伸出来的j，由于要表现所有的xxxxx情况，如10011,01100，因此j是< 1 << n的。
                for(int k = 0; k < 1 << n; k ++){//收集所有满足第i列伸出来的为j的所有第i-1列伸出来的为k的情况。并计算和。
                    if((j & k) == 0 && v[j | k]){//看当前的j和k是否能契合，j & k是10011,01100能否合在一起，如果两个地方都有1就是冲突的。j | k代表,都是1的情况，如10011,01100，合就是11111，没有连续的0，因此是合法的，如果是10000,01000，合就是11000，有三个连续的0，就是不合法的。为什么用|是因为考虑的是i-1列，需要i-1列的所有空白的格子只能是偶数个，因为如果是奇数个，那么只能填横的格子，但是这样就和i的状态为j冲突了，因此是j|k不能有连续的格子。
                        dp[i][j] += dp[i - 1][k];//把j和k看成一个二进制的数，j由i-1状态下的k转移而来，由于能契合当前j的k有很多个，因此这里多了一个k层的循环，是为了寻找符合这种j的所有的k，然后总和就是i列伸出的为j的总方案数。
                    }
                }
            }
        }
        cout << dp[m][0] << endl;
    }
    return 0;
}

最短Hamilton路径蓝桥杯算法总结_第58张图片dp[i , j]表示从0走到j，经过了i的所有路径。i是二进制表示，表示通过了哪些点，如10011通过了1 4 5。

那么状态转移方程是什么样的呢？

由于dp[i , j]是从0走到j，经过了i的所有路径，那么在前一个状态就应该是没有从0走到k，经过了i除去j的所有路径，而由于i是二进制，所以i除去j的所有路径就是i-j，所有dp[i , j] = min(dp[i - j , k])，k 从0到n-1

#include
#include
using namespace std;

const int N = 21, M = 1 << N ;

int a[N][N], n;//从0走到j，经过了i这些点的所有路径
int dp[M][N];

int main(){
    cin >> n;
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < n; j ++)
            cin >> a[i][j];
    
    memset(dp, 0x3f, sizeof dp);
    
    dp[1][0] = 0;
    
    for(int i = 0; i < 1 << n; i ++){//i为二进制的数,000000-111111的范围。
        for(int j = 0; j < n; j ++){//j是到达的点。
            if(i >> j & 1){//i >> j & 1 是为了判断i中有哪些结点是可以通过的，只有到过了那个结点才能让前一个状态为没到过那个结点的。
                for(int k = 0; k < n; k ++){//k从0到n-1，代表是结点0到n-1，
                    if((i - (1 << j)) >> k & 1){//如果i去掉了j这个结点还有哪些结点是经过的，如果结点是经过的，那么dp[i][j] = dp[经过i这些点 除了 j这个结点][到k] + 从k这个结点到j的路径的最小值就是所求。
                    //如i为11010,j=2,那么i - j << 1就是11010-00010=11000，这就是除去了j这个结点后还经过的结点，对于这些经过的结点再加上k到j的路径，就是通过i这些结点到j的路径。寻找这些路径的最小值，就是需要的值。比如k=4,那么就是dp[11000][4] + a[4][2]。
                        dp[i][j] = min(dp[i][j], dp[i - (1 << j)][k] + a[k][j]);
                    }
                }
            }
        }
    }
    cout << dp[(1 << n) - 1][n - 1] << endl;
    return 0;
}

状态压缩的DP问题这种状态表示的含义有点难理解，还有就是状态转移的情况中有些无意义的情况要舍去。

7. 树状DP

没有上司的舞会

蓝桥杯算法总结_第59张图片

#include
#include
#include
using namespace std;

const int N = 6010;

int n;
int h[N], e[N], ne[N], idx;
int dp[N][N];
int happy[N];
bool has_father[N];

void add(int a, int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++ ;
}

void dfs(int u){
    dp[u][1] += happy[u];
    for(int i = h[u]; i != -1; i = ne[i]){
        int j = e[i];
        dfs(j);
        dp[u][1] += dp[j][0];
        dp[u][0] += max(dp[j][0],dp[j][1]);
    }
}

int main(){
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> happy[i];
    
    memset(h, - 1, sizeof h);
    
    for(int i = 1; i < n; i ++){
        int a, b;
        cin >> a >> b;
        has_father[a] = true;
        add(b, a);
    }
    int root = 1;
    while(has_father[root]) root ++;
    
    dfs(root);
    
    cout << max(dp[root][0], dp[root][1]) << endl;
    
    return 0;
    
}

8. 记忆化搜索

滑雪

蓝桥杯算法总结_第60张图片蓝桥杯算法总结_第61张图片

//y总的算法
#include
#include
using namespace std;
const int N = 310;

int a[N][N];
int dp[N][N];
int n, m;
int dx[4] = {1, - 1, 0, 0} , dy[4] = {0, 0, 1, - 1};

int f(int x, int y){
    int &v = dp[x][y];//&v的话之后对v的运算也就是对dp[x][y]的运算。
    if(v != -1) return v;//如果v不为-1代表已经访问过dp[x][y]了。这个感觉有没有无所谓，因为dp[x][y]不可能二次访问，因为从(x,y)到(x_now,y_now)，由于严格单调，所以后面的条件应该能够限制不可能再返回去。刚刚经过了思考，这样子好像可以节省一些时间。
    v = 1;
    for(int i = 0; i < 4; i ++){
        int x_now = x + dx[i], y_now = y + dy[i];
        if(a[x_now][y_now] > a[x][y] && x_now >= 1 && x_now <= n && y_now >=1 && y_now <= m){
            v = max(v, f(x_now, y_now) + 1);
        }
    }
    return v;
}


int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            cin >> a[i][j] ;

    memset(dp, -1, sizeof dp);
    
    int res = 0;
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            res = max(res, f(i , j));
        }
    }
    
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    
    cout << res << endl;
    return 0;
    
}
//类似我之前用的深度优先搜索的算法。我那个是每次到了return的时候看看res = max(res, 当前的路径深度)。然后最终输出res。
// #include
// #include
// using namespace std;
// const int N = 310;

// int a[N][N];
// int dp[N][N];
// int n, m, res;
// int dx[4] = {1, - 1, 0, 0} , dy[4] = {0, 0, 1, - 1};


// void dfs(int x,int y,int lujin){
//     int cnt = 0;
//     for(int i = 0; i < 4; i ++){
//         int x_now = x + dx[i], y_now = y + dy[i];
//         if(a[x_now][y_now] > a[x][y] && x_now >= 1 && x_now <= n && y_now >=1 && y_now <= m){
//             cnt ++;
//             dfs(x_now, y_now, lujin + 1);
//         }
//     }
//     if(!cnt) res = max(res, lujin);
// }

// int main(){
//     cin >> n >> m;
//     for(int i = 1; i <= n; i ++)
//         for(int j = 1; j <= m; j ++)
//             cin >> a[i][j] ;
    
//     for(int i = 1; i <= n; i ++){
//         for(int j = 1; j <= m; j ++){
//             dfs(i,j,1);
//         }
//     }
//     cout << res << endl;
// }

6. 贪心

区间选点

蓝桥杯算法总结_第62张图片

#include
#include
using namespace std;
const int N = 1e5 + 10;
int n;
struct Range{
    int l, r;
    bool operator <(const Range R){
        return r < R.r;
    }
}range[N];

int main(){
   cin >> n;
   for(int i = 0; i < n; i ++){
       int l, r;
       cin >> l >> r;
       range[i] = {l, r};
   }
   sort(range, range + n);
   int end = - 2e9;
   int res = 0;
   for(int i = 0; i <= n; i ++){
       if(range[i].l > end){
           end = range[i].r;
           res ++ ;
       }
   }
   cout << res << endl;
   return 0;
}

区间分组蓝桥杯算法总结_第63张图片

#include
#include
#include
using namespace std;
const int N = 1e5 + 10;
int n,max_R[N];
struct Range{
    int l, r;
    bool operator <(const Range R){
        return l < R.l;
    }
}range[N];

int main(){
   cin >> n;
   for(int i = 0; i < n; i ++){
       int l, r;
       cin >> l >> r;
       range[i] = {l, r};
   }
   sort(range, range + n);
   
//   memset(max_R, 0x3f, sizeof max_R);
    for(int i = 0 ; i < n; i ++){
        max_R[i] = - 2*1e9;
    }
    max_R[0] = range[0].r;
    int cnt = 1;
    for(int i = 1; i < n; i ++){
        int flag = 1;
        for(int j = 0; j < cnt; j ++){
            if(range[i].l > max_R[j]){
              max_R[j] = range[i].r;
              flag = 0;
              break;
            }
        }
        if(flag) max_R[cnt ++] = range[i].r;
    }
   cout << cnt << endl;
   return 0;
}

区间覆盖蓝桥杯算法总结_第64张图片

#include
#include
#include
using namespace std;
const int N = 1e5 + 10;
int n,max_R[N];
bool success;
struct Range{
    int l, r;
    bool operator <(const Range R){
        return l < R.l;
    }
}range[N];

int main(){
    int s, t;
    cin >> s >> t;
    cin >> n;
    for(int i = 0; i < n; i ++){
       int l, r;
       cin >> l >> r;
       range[i] = {l, r};
    }
    sort(range, range + n);
   
//   memset(max_R, 0x3f, sizeof max_R);
    int res = 0;
    for(int i = 0; i < n; i ++){
        int j = i, r = -2e9;
        while(j < n && range[j].l <= s){
            r = max(r, range[j].r);
            j ++ ;
        }
        
        if(r <= s){//这里只是判断每次往左是否有增加，只要增加了就不是-1，而不是判断最终是否覆盖了ed。
            res = -1;
            break;
        }
        
        res ++;
        
        if(r >= t){
            success = true;//成功了就是覆盖了ed,否则就是没有覆盖ed
            break;
        }
        s = r;
        i = j - 1;
    }
    if(success) cout << res << endl;
    else cout << "-1" << endl;
    return 0;
}

合并果子

#include
#include
#include
using namespace std;
const int N = 10010;
int a[N];
int n;
int main(){
    cin >> n;
    priority_queue, greater> heap;//定义一个小根堆。
    while(n --){
        int x;
        cin >> x;
        heap.push(x);
    }
    int res = 0;
    while(heap.size() > 1){
        int a = heap.top();
        heap.pop();
        int b = heap.top();
        heap.pop();
        res += a + b;
        heap.push(a + b);
    }
    cout << res << endl;
    return 0;
}

排队打水

蓝桥杯算法总结_第65张图片

#include
#include
using namespace std;
typedef long long LL;
const int N = 1e5 + 10;
int n;
int a[N];

int main(){
    cin >> n;
    for(int i = 0; i < n; i ++ ) cin >> a[i];
    sort(a, a + n);
    LL res = 0;
    for(int i = 0; i < n; i ++) res += a[i] * (n - i - 1);
    cout << res << endl;
    return 0;
}

耍杂技的牛蓝桥杯算法总结_第66张图片

我在这个题想的贪心算法证明是这样的。

假设牛从上往下依次为1,2…,n，则有 x 1 = 0 − s 1 x 2 = w 1 − s 2 = x 1 + w 1 + s 1 − s 2 x 3 = w 1 + w 2 − s 3 = x 2 + w 2 + s 2 − s 3 x i = x i − 1 + w i − 1 + s i − 1 − s i x_1=0-s_1 \\x_2=w_1-s_2=x_1+w_1+s_1-s_2\\x_3=w_1+w_2-s_3=x_2+w_2+s_2-s_3\\x_i=x_{i-1}+w_{i-1}+s_{i-1}-s_i x1​=0−s1​x2​=w1​−s2​=x1​+w1​+s1​−s2​x3​=w1​+w2​−s3​=x2​+w2​+s2​−s3​xi​=xi−1​+wi−1​+si−1​−si​

因此有 w i − 1 + s i − 1 − s i w_{i-1}+s_{i-1}-s_i wi−1​+si−1​−si​尽可能小时， x i x_i xi​最小，所以按照 w i − 1 + s i − 1 < w i + s i w_{i-1}+s_{i-1}wi−1​+si−1​<wi​+si​来从小到大排序​。

#include
#include
using namespace std;
const int N = 50010;
int a[N], s[N];
int n;

struct Cow{
    int w, s;
    bool operator <(Cow c){
        return s + w < c.s + c.w;
    }
}cow[N];

int main(){
    cin >> n;
    for(int i = 0 ; i < n; i ++ ){
        int w, s;
        cin >> w >> s;
        cow[i] = {w,s};
    }
    
    sort(cow, cow + n);
    
    for(int i = 1; i <= n; i ++) s[i] = s[i - 1] + cow[i - 1].w;
    
    int res = -2e9;
    
    for(int i = 0; i < n ; i ++){
        res = max(res, s[i] - cow[i].s);
    }
    
    cout << res << endl;
    return 0;
}

7. 杂记

利用stringstreams把一整行作为输入并读取数据

string line;
stringstreams ssin(line);
auto p;
while(ssin >> p){

}

利用数组做哈希

在数组的函数不需要太大的时候最好是使用数组本身做映射，因为在利用map的时候，时间会用的太长了，除非是数组的范围需要开到很大，而需要映射的点不多的时候再用map

超级源点

当题目中需要我们求某点到某些点的最短路等涉及到多个点的情况的时候，通常我们会选择虚拟出一个超级源点或者超级汇点，其与需要的多个点的距离为0，那么从这个点到某个点的最短路就是某个点到某些点的最短路，如果源点和汇点都是虚拟的超级点，那么就是从某些点到某些点的最短路。

在最短路中和最小生成树中总会出现。

你可能感兴趣的:(蓝桥杯算法,算法,蓝桥杯,c++)

  • 数据结构奇妙旅程之深入解析快速排序 山间漫步人生路 数据结构排序算法算法
    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • php 把一个数组分成有n个元素的二维数组的算法 风清扬-独孤九剑 phpphp算法
    一、第一种解法0){$columns_map[$position]++;//这个地方格外注意,$position与$columns比较$position=($position<$columns-1)?++$position:0;$array_length--;}foreach($columns_mapas$val){$newarray[]=array_splice($array,0,$val);}
  • 【算法分析与设计】去除重复字母 五敷有你 算法分析与设计javajavascript开发语言算法数据结构
    个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
  • c++中如何判断变量的数据类型，并输出 xnrbjy c++开发语言
    C++中如果想要判断变量的数据类型，可以使用typeid运算符。该运算符返回一个std::type_info类型的对象，可以使用name()方法获取其名称从而确定变量的类型，例如：#include#includeusingnamespacestd;intmain(){inta=123;floatb=3.14;boolc=true;chard='A';stringe="HelloWorld";cou
  • C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
    C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
  • yarn的安装和使用全网最详细教程 zxj19880502 yarnnpm
    一、yarn的简介：Yarn是facebook发布的一款取代npm的包管理工具。二、yarn的特点：速度超快。Yarn缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快。超级安全。在执行代码之前，Yarn会通过算法校验每个安装包的完整性。超级可靠。使用详细、简洁的锁文件格式和明确的安装算法，Yarn能够保证在不同系统上无差异的工作。三、yarn的
  • 图论记录之最短路迪杰斯特拉 Just right 算法图论java开发语言
    简述思想这个思想能用一句话来概括，精简到的极致:每次找到一个最短距离的点并更新起点到各个点的最短距离如果要可视化的话，B站搜索Dijksra算法，有视频讲解伪代码写到这里，其实是想整一个动画的，这样效果更好点，但由于种种原因所以就拖一下intdijkstr(){dist[1]=0;其余的点的距离全部初始化为真无穷，不要写成int的最大值迭代n次将不在s中的，且距离最近的点给tsj即先到t，再加上t
  • 大创项目推荐 深度学习 opencv python 公式识别(图像识别 机器视觉) laafeer python
    文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
  • 关于举办第十五届蓝桥杯全国软件和信息技术专业人才大赛项目实战赛的通知 QSNKJJSW 蓝桥杯职场和发展青少年编程无人机机器人科技人工智能
    各高等院校及相关单位：为贯彻落实《中国教育现代化2035》和《国务院关于印发新时期促进集成电路产业和软件产业高质量发展若干政策的通知》有关精神，为我国制造强国和网络强国战略提供人才支持，提高学生自主创新意识和工程实践能力，工业和信息化部人才交流中心决定举办第十五届蓝桥杯全国软件和信息技术专业人才大赛——项目实战赛。大赛连续四年入围中国高等教育学会“全国普通高校大学生竞赛排行榜”竞赛项目榜单。现将项
  • 排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现） 宇宙之一粟 不归路之Python#IT面试题收集与总结数据结构与算法算法数据结构排序算法pythonjava
    文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
  • 【数据结构】实验一 实现顺序表各种基本运算的算法 张鱼·小丸子 数据结构实验c++数据结构
    题目：实现顺序表各种基本运算的算法要求：1、建立一个顺序表，输入n个元素并输出；2、查找线性表中的最大元素并输出；3、在线性表的第i个元素前插入一个正整数x；4、删除线性表中的第j个元素；5、将线性表中的元素按升序排列；6、将线性表中的元素就地逆序（只允许用一个暂存单元）；#include#defineSIZE1000usingnamespacestd;typedefstruct{int*a;//
  • python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
    第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
  • C++ pdf 打印 插入图片 灿烂李 java前端服务器
    一：使用PODOFO给PDF插入图片：#includeintmain(){PoDoFo::PdfMemDocumentpdfDocument;PoDoFo::PdfPage*page;PoDoFo::PdfImageimage;PoDoFo::PdfVecObjects*vec_objects;PoDoFo::PdfRectrect;//打开PDF文档pdfDocument.loadFromFil
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • 第七章 索引及执行计划，存储引擎 执笔为剑 #MySQL运维篇编辑器mysql
    第七章索引及执行计划，存储引擎1，索引及执行计划1，作用：提供类似书目录的作用，目的是优化查询2，所用的种类（根据算法）B树索引Hash索引R树FulltextGIS3，B树基于不同的查找算法分类介绍B-tree：在范围查询方面提供了更好的性能（>showengines;#存储引擎作用在表上，不同的表可能有不同的存储引擎mysql>select@@default_storage_engine;#查
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 优化选址问题 | 基于和声搜索算法求解基站选址问题含Matlab源码 天天酷科研 优化选址问题（LP）matlab和声搜索算法基站选址问题
    目录问题代码问题和声搜索算法（HarmonySearch,HS）是一种模拟音乐创作过程中乐师们凭借自己的记忆，通过反复调整各乐器的音调，直至达到最美和声状态为启发，通过反复调整解向量的各分量来寻求全局最优解的智能优化算法。下面是一个基于和声搜索算法求解基站选址问题的Matlab伪代码框架。请注意，这个框架是一个基本的实现，你可能需要根据你的具体问题和约束条件进行调整和优化。代码%和声搜索算法求解基
  • 《外观模式（极简c++）》 Bovinitwo 设计模式（极简c++版）c++开发语言
    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
  • OpenCV（一个C++人工智能领域重要开源基础库） 简介 愚梦者 OpenCV人工智能人工智能opencvc++图像处理计算机视觉开源
    返回：OpenCV系列文章目录（持续更新中......）上一篇：OpenCV4.9.0配置选项参考下一篇：OpenCV4.9.0开源计算机视觉库安装概述引言：OpenCV（全称OpenSourceComputerVisionLibrary）是一个基于开放源代码发行的跨平台计算机视觉库，可以用来进行图像处理、计算机视觉和机器学习等领域的开发。该库由英特尔公司于1999年开始开发，最初是为了加速处理器
  • 动态多态的注意事项 Austin_1024 动态多态静态多态虚函数子类重写父类虚函数实现动态多态
    大家好：衷心希望各位点赞。您的问题请留在评论区，我会及时回答。多态的基本概念多态是C++面向对象三大特性之一（多态、继承、封装）多态分为两类：静态多态：函数重载和运算符重载属于静态多态，复用函数名。动态多态：通过派生类和虚函数实现运行时多态。静态多态和动态多态的区别：静态多态的函数地址早绑定——编译阶段确定函数地址。动态多态的函数地址晚绑定——运行阶段确定函数地址。下面通过案例讲解多态：#incl
  • 【循环神经网络rnn】一篇文章讲透 CX330的烟花 rnn人工智能深度学习算法python机器学习数据结构
    目录引言二、RNN的基本原理代码事例三、RNN的优化方法1长短期记忆网络（LSTM）2门控循环单元（GRU）四、更多优化方法1选择合适的RNN结构2使用并行化技术3优化超参数4使用梯度裁剪5使用混合精度训练6利用分布式训练7使用预训练模型五、RNN的应用场景1自然语言处理2语音识别3时间序列预测六、RNN的未来发展七、结论引言众所周知，CNN与循环神经网络（RNN）或生成对抗网络（GAN）等算法结
  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解 爱跑步的程序员~ 刷题蓝桥杯省赛
    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
  • C/C++中的Static关键字 SuhyOvO C语言C++c语言c++
    Static关键字在C和C++编程中是不可或缺的一部分，它用于定义具有持久存储期的变量和函数，以及类的静态成员。虽然它的使用相对直接，但不恰当的使用可能会导致难以调试的错误和混淆。本文将探讨static关键字的概念、作用以及在C和C++中的具体应用。文章目录第一部分：深入理解Static关键字定义和基本概念在C和C++中static的基本作用第二部分：Static在C语言中的使用静态全局变量静态局
  • C++进阶学习（3）类类型转换 一只特立独行猪 C++的学习c++学习
    文章目录一、类类型转换1.构造函数构造2.类型转换函数一、类类型转换数据类型转换在程序编译时或在程序运行实现基本类型←→基本类型基本类型←→类类型类类型←→类类型类对象的类型转换可由两种方式说明：构造函数转换函数称为用户定义的类型转换或类类型转换，有隐式调用和显式调用方式1.构造函数构造当类ClassX具有以下形式的构造函数：说明了一种从参数arg的类型到该类类型的转换ClassX::ClassX
  • C++ 如何去认识模板 SuhyOvO C++c++开发语言
    引言:C++模板是泛型编程的基石,允许程序员定义可与任何数据类型协作的函数和类。这种机制极大地增加了代码的灵活性和复用性,是C++最强大的特性之一。本文将深入探讨C++模板的概念、优势以及使用方法,帮助读者掌握这一重要的编程工具。文章目录模板简介模板的优势一、模板基础1.1模板的概念1.2函数模板1.3类模板二、模板进阶2.1模板的实例化2.2模板的特化2.3模板的默认参数2.4模板的嵌套三、模板
  • C++面试题 虾仁A 面试c++
    目录一、堆和栈的区别二、C++中new、delte和malloc的区别三、什么是源对象四、C++有哪些设计模式五，你使用过C++哪些类型的指针一、堆和栈的区别特性堆栈申请方式由程序员显式申请和释放由系统自动分配和释放分配方式动态分配自动分配分配效率相对较慢，需要遍历内存链表寻找合适空间相对较快，系统直接分配内存地址不连续的内存区域连续的内存区域大小限制大小灵活，上限取决于虚拟内存大小固定，通常较小
  • 15届蓝桥杯备赛(3) sad_liu #sad_liu的刷题记录蓝桥杯职场和发展
    文章目录15届蓝桥杯备赛(3)回溯算法组合组合总和III电话号码的字母组合组合总和组合总和II分割回文串子集子集II非递减子序列全排列全排列II贪心算法分发饼干最大子数组和买股票的最佳时机II跳跃游戏15届蓝桥杯备赛(3)提高C++程序的输入输出效率，尤其是在需要大量输入输出操作时。ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie
  • C++ primer 第十二章 红鼻子怡宝 c++primerc++开发语言
    动态分配的对象的生存期与它们在哪里创建无关，只有当显式地被释放时，这些对象才会销毁。静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存用来保存定义在函数内的非static对象。堆内存用来存储动态分配的对象。静态或栈内存中的对象由编译器自动创建和销毁，而堆内存中的对象必须显式地销毁它们。1.动态内存与智能指针运算符new在动态内存中为对象分配空间并返回一
  • 5. C++ 局部静态变量在什么时候分配内存和初始化？ 九五一 C++知识c++javajvm开发语言数据结构
    C++局部静态变量在什么时候分配内存和初始化？对于C语言的全局和静态变量，不管是否被初始化，其内存空间都是全局的；如果初始化，那么初始化发生在任何代码执行之前，属于编译期初始化。由于内置变量无须资源释放操作，仅需要回收内存空间，因此程序结束后全局内存空间被一起回收，不存在变量依赖问题，没有任何代码会再被执行！C++引入了对象，这给全局变量的管理带领新的麻烦。C++的对象必须有构造函数生成，并最终执
  • 安装数据库首次应用 Array_06 javaoraclesql
    可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面 这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 注意第一次，使用SQL D
  • Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 一.修改Console密码         打开weblogic控制台，安全领域 --> myrealm -->&n
  • IllegalStateException: Cannot forward a response that is already committed Cwind javaServlets
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。 示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
  • 基于流的装饰设计模式 木zi_鸣 设计模式
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 自定义的类成为装饰类 模仿BufferedReader，对Reader进行包装，体现装饰设计模式 装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 装饰类因为增强已有对象，具备的功能该
  • Linux中的uniq命令 被触发 linux
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件 说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
  • 正则表达式Pattern 肆无忌惮_ Pattern
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。   例如，我们需要对QQ号码格式进行检验 规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
  • Oracle高级查询之OVER (PARTITION BY ..) 知了ing oraclesql
    一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
  • Python调试 矮蛋蛋 pythonpdb
    原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
    今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。 进行debug之后，发现服务器端返回的确实是有值的对象。 后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针 百合不是茶
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：   定义一个指针p来指向a的地址（&是地址符号）：        
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
  • spring aop实例annotation方法实现 bijian1013 javaspringAOPannotation
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
  • [Velocity一]Velocity语法基础入门 bit1129 velocity
    用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html   注释 1.行级注释## 2.多行注释#*  *#   变量定义 使用$开头的字符串是变量定义，例如$var1, $var2,   赋值 使用#set为变量赋值，例
  • 【Kafka十一】关于Kafka的副本管理 bit1129 kafka
    1. 关于request.required.acks   request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在   Th
  • lua统计nginx内部变量数据 ronin47 lua nginx　 统计
    server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
  • java-11.二叉树中节点的最大距离 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
  • Netty源码学习-ReadTimeoutHandler bylijinnan javanetty
    ReadTimeoutHandler的实现思路： 开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
  • jquery验证上传文件样式及大小(好用) cngolon 文件上传jquery验证
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
  • 浏览器兼容【转】 cuishikuan css浏览器IE
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 碰到频率:100% 解决方案：CSS里    *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell$#$?特殊变量
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949   特殊变量列表 变量 含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
  • android Activity间List传值 dcj3sjt126com Activity
    第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
  • tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space   ------------
  • Android 数据库事务处理 gqdy365 android
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
  • Java 打开浏览器 hw1287789687 打开网址open浏览器open browser打开url打开浏览器
    使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址 使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chromeGooglegoogle apichrome插件
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
  • 进程VS.线程 m635674608 线程
    资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 多进程模式最大
  • Linux下安装MemCached 字符串 memcached
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
  • java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 javaDAO设计模式AOP
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
    2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他