准备2023（2024）蓝桥杯

news2025/1/24 8:52:18

前缀和

一维前缀和

s[i]=s[i-1]+a[i]

二维前缀和（子矩阵的和）
s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j]

差分

一维数组
	//b是差分数组
    b[i]+=c;
    b[j+1]-=c;

例题
在这里插入图片描述

#include<iostream>
using namespace std;
int n,m;
int b[100002],a[100002];
void insert(int i,int j,int c)
{
    b[i]+=c;
    b[j+1]-=c;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        insert(i,i,a[i]);
    }
    for(int i=1;i<=m;i++)
    {
        int l,r,c;
        cin>>l>>r>>c;
        insert(l,r,c);
        
    }
    for(int i=1;i<=n;i++)
    {
        a[i]=a[i-1]+b[i];
        cout<<a[i]<<' ';
    }
}

二维差分（差分矩阵）

在这里插入图片描述

b[x1][y1]+=c;
b[x2+1][y1]-=c;
b[x1][y2+1]-=c;
b[x2+1][y2+1]+=c;

例题：
在这里插入图片描述

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 1e3 + 10;
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()
{
    int n, m, q;
    cin >> n >> m >> q;
    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++)
        {
            insert(i, j, i, j, a[i][j]);      //构建差分数组
        }
    }
    while (q--)
    {
        int x1, y1, x2, y2, c;
        cin >> 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++)
        {
            a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1]+b[i][j];  //二维前缀和
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

字符串的操作STL

#include<string>
string s;
s.size();
s.length();
tolower(a);//将大写字母a，转换为小写字母，返回值是小写字母；a=tolower(a);

字符串

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
using namespace std;
string s[10];//可以读入二维的字符串
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>s[i];
    }
    for(int i=1;i<=n;i++)
    {
        cout<<s[i]<<endl;
    }
}

在这里插入图片描述

模拟

模拟题可难也可简单，重点是 读懂题意，抽象出来模型（我这说的好像是废话 ）
例题（简单）
在这里插入图片描述

#include <iostream>
#include<string>
using namespace std;
int n,m;
string a[102];
int d[8][2]={{-1,1},{1,-1},{0,1},{0,-1},{1,1},{-1,-1},{1,0},{-1,0}};
int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            int ans=0;
            if(a[i][j]=='*')
            {
                cout<<a[i][j];
                continue;
            }
            for(int k=0;k<8;k++)
            {

                    if((i+d[k][0])>=0&&(i+d[k][0]<n)&&(j+d[k][1]>=0)&&j+d[k][1]<m&&a[i+d[k][0]][j+d[k][1]]=='*')
                    {
                        ans++;
                    }


            }
            cout<<ans;
        }
        cout<<endl;
    }
    return 0;
}

闰年的判断

bool is_leap(int n)
{
    if((n%4==0&&n%100!=0)||(n%400==0))
    {
        return true;
    }
    return false;
}

高精度

高精度加法

例题
在这里插入图片描述

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
using namespace std;
vector<int>A,B,C;
string a,b;
void add()
{
    int t=0;
    for(int i=0;i<A.size()||i<B.size();i++)
    {
        if(i<A.size())
        {
            t+=A[i];
        }
        if(i<B.size())
        {
            t+=B[i];
        }
        C.push_back(t%10);
        t=t/10;
    }
    if(t)
    {
        C.push_back(t);
    }
}
int main()
{
    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');
    }
    add();
    for(int i=C.size()-1;i>=0;i--)
    {
        cout<<C[i];
    }
}

高精度乘法

高精度乘低精度

例题
在这里插入图片描述

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
using namespace std;
vector<int>A,B,C;
string a;
int b;
void mul()
{
    int t=0;
    for(int i=0;i<A.size();i++)
    {
        t+=A[i]*b;
        C.push_back(t%10);
        t=t/10;
    }
    if(t)
    {
        C.push_back(t);
    }
    while(C.size()>1&&C.back()==0)
    {
        C.pop_back();//把前导零删除
    }
}
int main()
{
    cin>>a>>b;
    for(int i=a.size()-1;i>=0;i--)
    {
        A.push_back(a[i]-'0');
    }
    mul();
    for(int i=C.size()-1;i>=0;i--)
    {
        cout<<C[i];
    }
}

高精度乘高精度

例题
在这里插入图片描述

在这里插入图片描述

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
using namespace std;
vector<int>A,B;
string a,b;
vector<int> mul()
{
    vector<int>C(A.size()+B.size()+7,0);
    int t=0;
    for(int i=0;i<B.size();i++)
    {
        for(int j=0;j<A.size();j++)
        {
            C[i+j]+=B[i]*A[j];
        }
    }
    for(int i=0;i<C.size();i++)
    {
        t+=C[i];
        C[i]=t%10;
        t/=10;
    }
    if(t)
    {
        C.push_back(t);
    }
    while(C.size()>1&&C.back()==0)
    {
        C.pop_back();
    }
    return C;
}
int main()
{
    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');
    }
    auto C=mul();
    for(int i=C.size()-1;i>=0;i--)
    {
        cout<<C[i];
    }
}

数学知识

卡特兰数

C0 = 1,         
C1 = 1,         C2 = 2,          C3 = 5,          C4 = 14,          C5 = 42,
C6 = 132,       C7 = 429,        C8 = 1430,       C9 = 4862,        C10 = 16796,
C11 = 58786,    C12 = 208012,    C13 = 742900,    C14 = 2674440,    C15 = 9694845,
C16 = 35357670, C17 = 129644790, C18 = 477638700, C19 = 1767263190, C20 = 6564120420, ...

递推公式
在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include<algorithm>
using namespace std;
//卡特兰数，用的是第二个公式
const int n=10;
int c[n];
int main()
{
    c[1]=1,c[2]=1;
    for(int i=3;i<=n;i++)
    {
        for(int j=1;j<i;j++)
        {
            c[i]+=c[j]*c[i-j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        printf("c[%d]=%d\n",i,c[i]);
    }
    return 0;
}

在这里插入图片描述
相关题目练习可以参考这位大佬的总结

组合数学

例题
在这里插入图片描述

#include<iostream>
using namespace std;
int n;
const int mod=1e9+7;
const int N = 2004;
int c[2004][2004];
 int a,b;
void init()
{
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(!j)
            {
                c[i][j]=1;
            }
            else
            {
                c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
            }
        }
    }
}
int main()
{
    cin>>n;
   
    init();
    while(n--)
    {
        scanf("%d%d",&a,&b);
        cout<<c[a][b]<<endl;
    }
}

例题
在这里插入图片描述

#include <iostream>//只有70分，不过是绿题啊，第一次做绿题，所以这种数学知识，如果没见过就超级难，一旦学过也就还好。

using namespace std;
const int N=2e3+3;
long long t,k;
unsigned long long c[N][N];
void cal()
{
    c[0][0]=0;
    for(int i=0;i<=2000;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(j==0)
            {
                c[i][j]=1;
            }
            else
            {
                c[i][j]=c[i-1][j]+c[i-1][j-1];
            }
        }
    }
}
int main()
{
    long long ans=0;
    cal();
    cin>>t>>k;
    int a,b;
    while(t--)
    {
        scanf("%d%d",&a,&b);
        for(int i=0;i<=a;i++)
        {
            for(int j=0;j<=min(i,b);j++)
            {
               // cout<<c[i][j]<<' ';
                if(c[i][j]%k==0)
                {
                    ans++;
                }
            }
        }
        cout<<ans<<endl;
        ans=0;
    }

    return 0;
}

素数筛（欧拉筛）

bool st[N];//st[i]为1，说明被筛掉了，也就是说，不是素数
int cnt=0;
for(int i=2;i<=n;i++)
{
	if(!st[i])
	{
		primes[cnt++]=i;
		for(int j=i+i;j<=n;j+=i)
		{
			st[j]=1;
		}
	}
}

例题
在这里插入图片描述

#include <iostream>

using namespace std;
const int N = 1e8+2;
bool st[N];
int primes[N];
int cnt;
int n,m;
void is_primes()
{
    for(int i=2;i<=n;i++)
    {
        if(!st[i])
        {
            cnt++;
            primes[cnt]=i;
            for(int j=i+i;j<=n;j+=i)
            {
                st[j]=1;
            }
        }
    }
}//TLE，只有四十分，埃氏筛效率还是低了些。1e8会TLE，例如一个数 24，它会被 2, 3, 4 三个数标记，这就重复了两次，更大的数同理。
int main()
{
    cin>>n>>m;
    int q;
    is_primes();
    while(m--)
    {
        scanf("%d",&q);
        printf("%d\n",primes[q]);
    }
    return 0;
}

线性筛

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

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

质因子分解

定理：一个合数可以由多个比他小的质数相乘而得，而这些质数就是他的质因数。

//要计算的是从1到n之间的所有合数的质因数
for(int i=1;i<=n;i++)
{
	int x=i;
	if(!st[x])//没有被筛掉，也就是是合数
	{
		continue;
	}
	else
	{
		for(int j=2;j<=x;j++)
		{
			while(x%j==0)
			{
				p[cnt++]=j;//p数组中存的是质因数
				x=x/j;
			}
		}
	}
}

用map实现
例题
在这里插入图片描述

#include<iostream>
#include<map>
using namespace std;
void fen(int n)
{
    map<int,int> m;
    for(int i=2;i<=n/i;i++)
    {
        if(n%i==0)
        {
            int c=0;
            while(n%i==0)
            {
                c++;
                n=n/i;
            }
            m[i]+=c;
        }
        
    }
    if(n>=2)//加上大于根号n的素因子
    {
        m[n]++;
    }
    map<int,int>::iterator iter;
    for(iter=m.begin();iter!=m.end();iter++)
    {
        printf("%d %d\n",iter->first,iter->second);
    }
    cout<<endl;
}
int main()
{
    int n,a;
    cin>>n;
    while(n--)
    {
        scanf("%d",&a);
        fen(a);
        
    }
    return 0;
}

约数个数定理

在这里插入图片描述
套用上面map实现的代码

void fen(int n)
{
    map<int,int> m;
    for(int i=2;i<=n/i;i++)
    {
        if(n%i==0)
        {
            int c=0;
            while(n%i==0)
            {
                c++;
                n=n/i;
            }
            m[i]+=c;
        }
        
    }
    if(n>=2)//加上大于根号n的素因子
    {
        m[n]++;
    }
    map<int,int>::iterator iter;
    for(iter=m.begin();iter!=m.end();iter++)
    {
        //printf("%d %d\n",iter->first,iter->second);
        res*=(iter->second+1);//这里
    }
    cout<<endl;
}

分离整数

while(n)
{
	a.push_back(n%10);//依次存储的是个位 十位等
	n=n/10;
}

例题

得到各个位数

//前三位
int n=1234567;
int x=n/10000;
//取后两位
int y=n%100;

进制转换

#include<iomanip>
setbase(n)
//hex十六进制，oct八进制，dec十进制

最大公约数

int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}

例题
这个例题中，主要是字符串的操作，最大公约数只是其中的一个应用，但是如果不会最大公约数和最小公倍数的话，也会很麻烦
在这里插入图片描述

#include<cstdio>
#include<iostream>
using namespace std;
int a,b,c,d;
int gcd(int x,int y)
{
    if(y==0)
        return x;
    return gcd(y,x%y);
}
int main()
{
    scanf("%d/%d",&a,&b);//这一步就很巧妙
    while(scanf("%d/%d",&c,&d)!=EOF)//EOF是先按Enter键，然后是Ctrl+z
    {
        int m=(b*d)/gcd(b,d);//最小公倍数*最大公约数=a*b
        a=a*(m/b)+c*(m/d);
        b=m;
        int x=gcd(a,b);
        a=a/x;
        b=b/x;
        //cout<<a<<'/'<<b<<endl;
    }
    if(b<0)
    {
        a=-a;
        b=-b;
    }
    if(b==1)
        printf("%d\n",a);
    else
        printf("%d/%d\n",a,b);
    return 0;
}

快速幂运算

例题
在这里插入图片描述
ps:十年OI一场空，不开long long见祖宗
附上数据范围
在这里插入图片描述

#include <iostream>

using namespace std;
long long a,b,p;
int n;
typedef long long ll;
ll qmi(ll a,ll b,ll q)
{
    ll res=1;
    while(b)
    {
        if(b&1)
        {
            res=((res%p)*(a%p))%p;
        }
        b>>=1;
        a=(a*a)%p;
    }
    return res;
}
int main()
{
    cin>>n;
    while(n--)
    {
        cin>>a>>b>>p;
        cout<<qmi(a,b,p)<<endl;

    }

    return 0;
}

贪心算法

取当前情况最好的，贪心不贪，重点在于排序加模拟。

例题
在这里插入图片描述
思路：等待时间最小，就是让接水时间最短的人先接。用sort排个序，因为是要输出排队的序号，所以就用pair了

#include <iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n;
int sum[1002];
pair<int,int>a[1002];
bool cmp(pair<int,int>x,pair<int,int>y)
{
    return x.second < y.second;
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        a[i].first=i;
        cin>>a[i].second;
    }
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=n;i++)
    {
        cout<<a[i].first<<' ';

    }
    cout<<endl;
    memset(sum,0,sizeof(sum));
    for(int i=2;i<=n;i++)
    {
        sum[i]=sum[i-1]+a[i-1].second;
    }
    double ans;
    for(int i=2;i<=n;i++)
    {
        ans+=sum[i];
    }
    ans=ans*1.0/n;
    printf("%.2lf",ans);
    return 0;
}

例题
在这里插入图片描述
思路：贪心就是取当前情况最好的。在这道题中，正向遍历，如果两者之和大于x,就吃掉a[i]中的，如果a[i]为0了，就吃掉a[i-1]中的糖果。因为后面还有，如果先吃掉a[i-1]中的，对后面没啥影响，所以不是最好的情况。（至于理论证明为啥这样最好，本蒟蒻不会5555）

#include <iostream>
#include<algorithm>
#include<cmath>
using namespace std;
long long n,x;
long long a[100004];
int main()
{
    cin>>n>>x;
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    long long t=0;
    long long ans=0;
    long long temp=0;
    for(int i=2;i<=n;i++)
    {
        if(a[i-1]+a[i]>x)
        {
            temp=a[i];
            t=a[i-1]+a[i]-x;
            ans+=t;
            a[i]=a[i]-t;
            if(a[i]<0)
            {
                a[i]=0;
                a[i-1]=a[i-1]-(x-temp);//开始吃a[i-1]中的糖果
            }
        }
    }
    cout<<ans<<endl;
    return 0;
}

例题：
在这里插入图片描述
思路：这道题的标签是动态规划，但是数据范围有点大，而且俺也不会完全背包问题，及啥滚动数组，就用贪心做了，but只有90分。哭辽

#include <iostream>
#include<algorithm>
using namespace std;
int t,m;
const int N =1e4+2;
pair<int,int> p[N];
int d[N][N];
bool cmp(pair<int,int>x,pair<int,int>y)
{
    return (x.second*1.0/x.first) > (y.second*1.0/y.first);
}
int main()
{
    cin>>t>>m;
    int a,b;
    for(int i=0;i<m;i++)
    {
        cin>>a>>b;
        p[i].first=a;
        p[i].second=b;
    }
    sort(p,p+m,cmp);
    long long cost=t;
    long long val=0;//十年 OI 一场空，不开 long long 见祖宗。
    for(int i=0;i<m;i++)
    {
        while(cost>0)
        {
            val+=p[i].second;
            cost-=p[i].first;
        }
        if(cost<0)
        {
            cost+=p[i].first;
            val-=p[i].second;
        }
        if(cost==0)
        {
            break;
        }
    }
    cout<<val;

    return 0;
}

动态规划

格式化输出

//在C++中，cout<<int(2.56);输出就是2，只保留整数部分，如果要四舍五入，就要加上0.5
//可以用printf("%.2lf",2.56);自动进行四舍五入。此外，printf("%02d",6);表示输出占两位，不足两位添加前导0

STL

贴个大佬总结的STL食用指南

//自定义排序方式
bool cmp(int x,int y)
{
	return x>y;
}//表示按照从大到小的方式进行。这种定义方式，在pair或者结构体中使用范围更广

//例如
bool cmp(pair<int,int>x,pair<int,int>y)
{
	return x.first > y.first;
}//按照first的值升序排列；

//需要包含在头文件algorithm中
sort(a,a+n,cmp);//a为普通数组
sort(a,a+n,greater<int>());//降序，默认是升序
sort(a.begin(),a.end());//a为vector数组

reverse函数

用法示例（vector和数组）

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
using namespace std;
int main()
{
    vector<int> vec;
    int a[10];
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int c;
        cin>>c;
        vec.push_back(c);
        a[i]=c;
    }
    reverse(vec.begin(),vec.end());
    reverse(a,a+n);
    cout<<"vec"<<endl;
    for(int i=0;i<n;i++)
    {
        cout<<vec[i]<<' ';
    }
    cout<<endl;
    cout<<"数组a"<<endl;
    for(int i=0;i<n;i++)
    {
        cout<<a[i]<<' ';
    }
    cout<<endl;
}

在这里插入图片描述

去重（要求序列是有序的，首先用sort排序）

v.erase(unique(v.begin(),v.end()),v.end());

优先队列

priority_queue<Type, Container, Functional>

set

map

桶计数是map一个功能之一

#include<bits/stdc++.h>
using namespace std;
map<int,int>book;
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		int temp;
		cin>>temp;
		book[temp]++;
	}
	int k;
	cin>>k;
	cout<<book[k]<<endl;
	return 0;
}

二分查找

binary_search（起始地址，结束地址，要查找的数值）
返回值是 是否存在这么一个数，是一个bool值。

binary_search(a,a+n,3);

lower_bound（起始地址，结束地址，要查找的数值），返回值就是返回第一次出现大于等于那个要查找的数的地址；如果不存在则返回a.end()

lower_bound(a,a+n,3)-a;

upper_bound（起始地址，结束地址，要查找的数值）返回的是被查序列中第一个大于查找的数的指针；,如果不存在则返回a.end()

upper_bound(a,a+n,3)-a;

综合应用
查询某个元素出现的次数

upper_bound - lower_bound

 upper_bound(a,a+n,3)-lower_bound(a,a+n,3);

例题
在这里插入图片描述

#include <iostream>
#include<algorithm>
using namespace std;
int n,c;
const int N = 2e5+5;
int a[N];
int main()
{
    cin>>n>>c;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    sort(a+1,a+n+1);
    long long ans=0;//没开long long，只有90分
    //int posg=upper_bound(a+1,a+n+1,c)-a;这是之前的思路，只有76分
    for(int i=1;i<=n;i++)
    {
        //cout<<"a[i"<<a[i]<<endl;
        ans+=(upper_bound(a+1,a+n+1,a[i]+c))-(lower_bound(a+1,a+1+n,a[i]+c));
    }
    cout<<ans<<endl;
    return 0;
}

例题
在这里插入图片描述

#include <iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N = 1e6+3;
int a[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    int q;
    while(m--)
    {
        cin>>q;
        if(!binary_search(a+1,a+1+n,q))
        {
            cout<<-1<<' ';
        }
        else
        {
            int x=lower_bound(a+1,a+1+n,q)-a;
            cout<<x<<' ';
        }
    }
    return 0;
}

动态规划

考虑小规模。思考的时候，是由n-1推n,由n-2推n-1;写方程的时候，从1推2，推n

背包问题

0-1背包问题

例题
有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。第 i件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

0-1背包（朴素版）
#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N=1005;
int v[N],w[N],f[N][N];//f[i][j]表示背包容量为j时前i个物品的最大价值
int main()
{
	cin>>n>>m;//读入物品的数量和背包容量
	for(int i=1;i<=n;i++)
	{
		cin>>v[i]>>w[i];//读入每个物品的重量和价值
	}
	//dp
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<=m;j++)
		{
			if(j<v[i])
				f[i][j]=f[i-1][j];//如果背包容量小于物品的重量，那就不装
			else
			{
				f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i])//如果背包容量大于物品的重量，这时候就有两种选择，装或者不装，如果装入的话，j就要减去第i个物品的重量，这两种情况取其中的最大值
			}
		}
	}
	cout<<f[n][m]<<endl;
	return 0;
0-1背包（升级版）

解释：由于进行状态转移的过程中只用到了上一层的数据，所以可以进行降维。

#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N = 1e3+5;
int f[N],v[N],w[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=v[i];j--)
        {   
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}
完全背包问题（朴素版）

完全背包问题和0-1背包问题的区别就是每一种物品的个数是无限的。

#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N = 2e3+5;
int f[N][N],v[N],w[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;v[i]*k<=j;k++)
            {
                if(j<v[i])
                {
                    f[i][j]=f[i-1][j];
                }
                else
                {
                    f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
                }
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}
优化版
#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N = 2e3+5;
int f[N][N],v[N],w[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=v[i])
                f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

完全背包（再升级版）

#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N = 2e3+5;
int f[N],v[N],w[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=v[i];j<=m;j++)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

多重背包（朴素版）

#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
const int N = 110;
int f[N][N],v[N],w[N],s[N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i]>>s[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k<=s[i]&&k*v[i]<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

搜索bfs

使用队列，queue
例题
在这里插入图片描述
思路：本来想用最短路算法，迪杰斯特拉，看到题目标签是bfs，就用了bfs，我是菜鸡，呜呜。这题用pair正好。

#include <iostream>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
queue<PII>q;
const int N = 405;
int mp[N][N];
int d[8][2]={{1,-2},{1,2},{2,-1},{2,1},{-1,-2},{-1,2},{-2,-1},{-2,1}};
int vis[N][N];
int dis[N][N];
int n,m,x,y;
void bfs(int x,int y)
{
    PII temp;
    temp.first=x;
    temp.second=y;
    q.push(temp);
    vis[temp.first][temp.second]=1;
    while(!q.empty())
    {
        temp=q.front();
        q.pop();
        //vis[temp.first][temp.second]=0;此处不需要写，否则会死循环
        for(int i=0;i<8;i++)
        {
            int tx,ty;
            tx=temp.first+d[i][0];
            ty=temp.second+d[i][1];
            if(tx>=0&&tx<n&&ty>=0&&ty<m&&!vis[tx][ty])
            {
                q.push(make_pair(tx,ty));
                vis[tx][ty]=1;
                dis[tx][ty]=dis[temp.first][temp.second]+1;
            }
        }

    }
}
int main()
{
    cin>>n>>m>>x>>y;
    bfs(x-1,y-1);
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(dis[i][j]==0)
            {
                if(i==x-1&&j==y-1)
                {
                    cout<<0<<' ';
                }
                else
                {
                    cout<<-1<<' ';
                }
            }
            else
            {
                cout<<dis[i][j]<<' ';
            }
        }
        cout<<endl;
    }
    return 0;
}

dfs

搞清楚状态转移

全排列问题

//头文件algorithm
int a[4]={1,2,3,4};
do
{
	for(int i=0;i<4;i++)
	{
		cout<<a[i]<<' ';
	}
	cout<<endl;
}while(next_permutation(a,a+4));

在这里插入图片描述

图的基本应用

邻接表（用vector实现）

#include <iostream>
#include<vector>
#include<queue>
using namespace std;
const int N=1e5+3;
int vis[N];
vector<int>v[N];
queue<int> q;
int main()
{
    int n,m;
    cin>>n>>m;
    int a,b;
    for(int i=1;i<=n;i++)
    {
        v[i].push_back(i);
    }
    for(int i=0;i<m;i++)
    {
        cin>>a>>b;
        v[a].push_back(b);
        v[b].push_back(a);
    }
    for(int i=1;i<=n;i++)
    {
        int len=v[i].size();
        int maxx=0;
        cout<<i<<':';
        for(int j=0;j<len;j++)
        {
            cout<<v[i][j]<<' ';
        }
        //cout<<maxx<<' ';
        cout<<endl;
    }
    return 0;
}

在这里插入图片描述

单源最短路径

迪杰斯特拉算法

例题同下（这个算法不是靠队列实现的）
依然只有60分，因为我用的还是邻接矩阵

#include <iostream>
#include<cstring>
using namespace std;
const int N=1e4;
const int INF=0x3f;
int mp[N][N];
int vis[N];
int dis[N];
int n,m,s;
void dijstra(int s)
{

    dis[s]=0;
    //vis[s]=1;
    while(1)
    {
        int min_=INF,mini=0;
        for(int j=1;j<=n;j++)
        {
            if(dis[j]<min_&&!vis[j])//寻找没有确定为最短路径的点
            {
                min_=dis[j];
                mini=j;
            }
        }
        if(mini==0)
        {
            break;//没有找到就退出
        }
        vis[mini]=1;
        for(int i=1;i<=n;i++)
        {
            if(dis[i]>dis[mini]+mp[mini][i])
            {
                dis[i]=dis[mini]+mp[mini][i];//依次进行松弛
            }
        }

    }
}
int main()
{
    memset(mp,INF,sizeof(mp));
    memset(dis,INF,sizeof(dis));
    cin>>n>>m>>s;
    int a,b,w;
    while(m--)
    {
        cin>>a>>b>>w;
        mp[a][b]=min(mp[a][b],w);
    }
    dijstra(s);
    for(int i=1;i<=n;i++)
    {
        cout<<dis[i]<<' ';
    }
    return 0;
}

spfa算法：可以判断是否会存在负权边

例题
在这里插入图片描述

邻接矩阵版本（会MLE,只有60分）

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
int n,m,s;
const int N = 1e3+2;
const int INF=0x3f;
int mp[N][N];
queue<int> q;
int sum[N];
int dis[N],vis[N];
int cur;
void spfa(int s)
{
    q.push(s);
    vis[s]=1;
    dis[s]=0;
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        vis[cur]=0;
        for(int i=1;i<=n;i++)
        {
            if(mp[cur][i]!=INF)
            {
                if(dis[i]>dis[cur]+mp[cur][i])
                {
                    dis[i]=dis[cur]+mp[cur][i];
                    if(vis[i]!=1)
                    {
                        q.push(i);
                        vis[i]=1;
                        /*sum[i]++;
                        if(sum[i]>=n)
                        {
                            cout<<"有负权回路"<<endl;
                        }*/
                    }

                }
            }

        }
    }

}
int main()
{
    cin>>n>>m>>s;
    int a,b,w;
    memset(dis,INF,sizeof(dis));
    memset(mp,INF,sizeof(mp));
    for(int i=1;i<=m;i++)
    {
        cin>>a>>b>>w;
        mp[a][b]=min(mp[a][b],w);
    }
    spfa(s);
    for(int i=1;i<=n;i++)
    {
        cout<<dis[i]<<' ';
    }
}

邻接表版

并查集

例题
在这里插入图片描述

无路径压缩版本
（会TLE）

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
using namespace std;
int n,m;
int f[100002];
int find_(int x)
{
    if(x!=f[x])
    {
        find_(f[x]);
    }
    else
        return f[x];
}
int main()
{
    cin>>n>>m;
    char op;
    int a,b;
    for(int i=1;i<=n;i++)
    {
        f[i]=i;
    }
    while(m--)
    {
        cin>>op;
        cin>>a>>b;

        if(op=='M')
        {
            a=find_(a);
            b=find_(b);
            if(a!=b)
            {
                f[a]=b;
            }
        }
        if(op=='Q')
        {
            if(find_(a)==find_(b))
            {
                cout<<"Yes"<<endl;
            }
            else
            {
                cout<<"No"<<endl;
            }
        }
    }
    return 0;
}

路径压缩版

#include <iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
using namespace std;
int n,m;
int f[100002];
int find_(int x)
{
    if(x==f[x])
    {
        return f[x];
    }
    else
    {
        f[x]=find_(f[x]);//这里
        return f[x];
    }
        
}
void merge_(int a,int b)
{
    f[find_(a)]=find_(b);
}
int main()
{
    cin>>n>>m;
    char op;
    int a,b;
    for(int i=1;i<=n;i++)
    {
        f[i]=i;
    }
    while(m--)
    {
        cin>>op;
        cin>>a>>b;

        if(op=='M')
        {
            if(find_(a)!=find_(b))
                merge_(a,b);
        }
        if(op=='Q')
        {
            if(find_(a)==find_(b))
            {
                cout<<"Yes"<<endl;
            }
            else
            {
                cout<<"No"<<endl;
            }
        }
    }
    return 0;
}

一些注意事项

1.要记得 long long;
2.实现估算一下，如果循环次数超过10e8就要考虑进行优化，否则可能会TLE;
3.二维数组如果大于10e5可能会MLE,要考虑优化；
4.x%n的值为0到n-1；
5.EOF可以用不？
准备了近一个月。
尽人事，听天命吧。
事实证明，会这些基本的算法是不配参加蓝桥杯的 （赛后补充）
含泪捐了300元

附大佬总结的2016年真题

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/413737.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【系统集成项目管理工程师】信息系统集成及服务

【系统集成项目管理工程师】信息系统集成及服务

&#x1f4a5;信息系统集成及服务 1、信息技术基础架构库&#xff08;ITIL&#xff09; 简介&#xff1a; 最初是为了提高英国政府部门 IT 服务质量而开发&#xff0c;但它很快在英国的各个企业中得到了广泛的应用和认可。 ITIL 包含着如何管理IT 基础设施的流程描述&#xf…
阅读更多...
【OpenCV-Python】cvui 之 trackbar

【OpenCV-Python】cvui 之 trackbar

CVUI 之 trackbar cvui::trackbar() 渲染一个 trackbar&#xff0c; 可以左右拖动或点击对数字进行增加或减少的调整。 不使用离散间隔 使用离散间隔 Python import numpy as np import cv2 import cvuidef trackbar_test():WINDOW_NAME Trackbar-Test# 创建画布frame np.z…
阅读更多...
2023-数据质量管理方法总结

2023-数据质量管理方法总结

一、数据质量保障原则 如何评估数据质量的好坏&#xff0c;业界有不同的标准&#xff0c;阿里主要从4个方面进行评估&#xff1a;完整性、准确性、一致性、及时性&#xff1b; 1.完整性 数据完整性是数据最基础的保障&#xff1b; 完整性&#xff1a;指数据的记录和信息是否…
阅读更多...
Redis高级功能

Redis高级功能

目录 1.RDB 持久化 1.1生成RDB文件的命令 1.2RDB 文件结构 1.3RDB 文件结构 - database 部分 2.AOF 持久化 2.主从复制 2.1重同步 - 完整重同步 2.2重同步 - 部分重同步 2.2.1重同步 - 部分重同步的实现 - PSYNC的实现原理 3.复制的具体过程 3.Sentinel 哨兵模式 …
阅读更多...
MySQL Workbench使用入门

MySQL Workbench使用入门

软件介绍 MySQL Workbench 是可视化数据库设计软件&#xff0c;为数据库管理员和开发人员提供了一整套可视化的数据库操作环境&#xff0c;主要功能有数据库设计与模型建立、SQL 开发&#xff08;取代 MySQL Query Browser&#xff09;、数据库管理&#xff08;取代 MySQL Adm…
阅读更多...
【Vue框架】Vue2中element-ui/mint-ui组件库——element-ui引入组件以及使用案例、mint-ui引入组件及使用案例

【Vue框架】Vue2中element-ui/mint-ui组件库——element-ui引入组件以及使用案例、mint-ui引入组件及使用案例

文章目录一、element-ui/mint-ui组件库1.1 element-ui使用步骤1.1.1 引入组件1.1.2 修改 .babelrc文件1.2 mint-ui的使用1.2.1 安装引入组件1.2.2 Mint-ui相关组件一、element-ui/mint-ui组件库 element-ui 提供了大量的组件&#xff0c;如&#xff1a;布局组件、表单组件、JS…
阅读更多...
运行时内存数据区之虚拟机栈——动态链接、方法返回地址与一些附加信息

运行时内存数据区之虚拟机栈——动态链接、方法返回地址与一些附加信息

动态链接&#xff08;Dynamic Linking&#xff09;——指向运行时常量池的方法引用 每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking)。比如&#xff1a;invokedynamic指令。…
阅读更多...
算法 DAY24 回溯 || 第77题. 组合 216.组合总和III 17.电话号码的字母组合 39. 组合总和

算法 DAY24 回溯 || 第77题. 组合 216.组合总和III 17.电话号码的字母组合 39. 组合总和

前置知识 回溯算法模板框架如下&#xff1a;void backtracking(参数) {if (终止条件) {存放结果;return;}for (选择&#xff1a;本层集合中元素&#xff08;树中节点孩子的数量就是集合的大小&#xff09;) {处理节点;backtracking(路径&#xff0c;选择列表); // 递归回溯&am…
阅读更多...
rk3568点亮LCD(lvds)

rk3568点亮LCD(lvds)

rk3568 Android11/12 适配 lvds 屏 LVDS&#xff08;Low Voltage Differential Signal&#xff09;即低电压差分信号。1994年由美国国家半导体&#xff08;NS&#xff09;公司为克服以TTL电平方式传输宽带高码率数据时功耗大、电磁干扰大等缺点而研制的一种数字视频信号传输方…
阅读更多...
堆的实现

堆的实现

思维导图 堆的概念 普通的二叉树是不适合用数组来存储的&#xff0c;因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储&#xff0c;需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事…
阅读更多...
【LeetCode】剑指 Offer 50. 第一个只出现一次的字符 p243 -- Java Version

【LeetCode】剑指 Offer 50. 第一个只出现一次的字符 p243 -- Java Version

题目链接&#xff1a;https://leetcode.cn/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/ 1. 题目介绍&#xff08;50. 第一个只出现一次的字符&#xff09; 在字符串 s 中找出第一个只出现一次的字符。如果没有&#xff0c;返回一个单空格。 s 只包含小写字母。 【测…
阅读更多...
al文章生成-文章生成工具

al文章生成-文章生成工具

ai文章生成器 AI文章生成器是一种利用人工智能和自然语言处理技术生成文章的工具。它使用先进的算法、机器学习和深度学习技术&#xff0c;深度挖掘和提取大量数据背后的信息&#xff0c;自主学习并合并新的信息&#xff0c;生成优质、原创的文章。 使用AI文章生成器的优点如下…
阅读更多...
liunx mysql 主从同步设置 关键点

liunx mysql 主从同步设置 关键点

主库MySQL配置文件&#xff1a;该配置文件默认是在 /etc/my.cnf [mysqld] max_allowed_packet256M server-id1 log-binmysql-bin replicate-do-dbweb auto_increment_increment2 auto_increment_offset1 binlog_ignore_dbsys general_logon general_log_file/v…
阅读更多...
Qt下载以及调试

Qt下载以及调试

1.概念 Qt是一个跨平台的基于C图形用户界面应用程序框架。 常见GUI&#xff1a; Qt&#xff1a;支持多平台&#xff1b;支持css&#xff1b;面向对象特性体现突出&#xff1b;发展趋势良好&#xff1b; MFC&#xff1a;仅在Windows&#xff1b;运行程序效率高&#xff1b;库安…
阅读更多...
外包干了四年，感觉废了..

外包干了四年，感觉废了..

先说一下自己的情况&#xff0c;大专生&#xff0c;18年通过校招进入湖南某软件公司&#xff0c;干了接近4年的功能测试&#xff0c;今年年初&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了四年的功能测试…
阅读更多...
如何利用ventoy制作Linux to go （把deepin放到U盘里）

如何利用ventoy制作Linux to go （把deepin放到U盘里）

准备工作 最新版本 – 深度科技社区 (deepin.org) deepin镜像官方下载即可 Releases ventoy/vtoyboot GitHub ventoy启动插件选择1.0.29版本 Downloads – Oracle VM VirtualBox VirtualBox虚拟机官网 ventoy下载 VentoyRelease (lanzoui.com) 选择下载1.0.29版本 vento…
阅读更多...
表格软件界的卷王，Excel、access、foxpro全靠边，WPS:真荣幸

表格软件界的卷王，Excel、access、foxpro全靠边，WPS:真荣幸

Excel和Access就是表格软件的选择&#xff1f; 现在&#xff0c;铺天盖地的Excel的技能教程可谓是满天飞&#xff0c;有网上的教程&#xff0c;也有视频直播课程。 很多办公人员用Excel这种表格软件与VBA结合&#xff0c;甚至用不遗余力去学习Python编程语法&#xff0c;但Exce…
阅读更多...
2023年会计师事务所研究报告

2023年会计师事务所研究报告

第一章 行业发展概况 1.1 行业概况 会计师事务所是专门从事财务、税务等领域的专业服务机构&#xff0c;其服务范围涵盖了审计、会计、税务、咨询等多个方面。 近年来&#xff0c;随着全球经济的不断发展和国际贸易的增加&#xff0c;会计师事务所行业也得到了快速发展。据统…
阅读更多...
G8期刊《全体育》期刊简介及投稿要求

G8期刊《全体育》期刊简介及投稿要求

G8期刊《全体育》期刊简介及投稿要求 《全体育》是由湖南体育产业集团有限公司主管、体坛传媒集团股份有限公司主办、中教体育 出版发行的体育综合性期刊。 主管&#xff1a;湖南体育产业集团有限公司 主办&#xff1a;体坛传媒集团股份有限公司 国内刊号&#xff1a;CN4…
阅读更多...
「实战教程」如何使用POI读取模板PPT填充数据并拼接至目标文件

「实战教程」如何使用POI读取模板PPT填充数据并拼接至目标文件

文章目录一、PPT文件格式介绍1、PPT文件格式的概述2、HSLF和XSLF的区别3、如何选择合适的POI类库二、SlideShow三、读取PPT文件1. 加载PPT文件2. 获取PPT文件中的幻灯片3. 获取幻灯片中的形状元素四、修改PPT文件内容1. 幻灯片操作1.1 新增幻灯片1.2 删除幻灯片1.3 移动幻灯片1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023