算法C++

已于 2024-03-18 20:28:59 修改
阅读量673 收藏 9
点赞数 11
文章标签： 算法 c++ 数据结构
于 2024-02-28 23:09:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Error_Fe/article/details/136310939
版权

枚举

1.化段为点

前缀和             eg:给一个数列，算x到y个数的和

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	int n;
	cin>>n;
	vector<int> a(n);
	vector<int> sum(n+1,0);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
		sum[i+1]=sum[i]+a[i];
	}
	int x,y;
	cin>>x>>y;
	cout<<sum[y]-sum[x-1];
 }

给一段数字，q次访问，每次对[x,y]区间进行加减x，最后再重新给出新的一段数字

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	int n;
	cin>>n;
	vector<int> a(n+1,0);
	vector<int> cha(n+1,0);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		cha[i-1]=a[i]-a[i-1]; 
	}
	int q;
	cin>>q;
	for(int i=0;i<q;i++)
	{
		int x,y,z;
		cin>>x>>y>>z;
		cha[x-1]+=z;
		cha[y]-=z;
	}
	for(int i=1;i<=n;i++)
	{
		a[i]=a[i-1]+cha[i-1];
		cout<<a[i]<<endl;
	}
}

n棵树,q次砍树区间为[x,y]，求之后树总数量

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

struct sb
{
	int pos,num;
};

bool compare(sb x,sb y)
{
	if(x.pos == y.pos )
	{
		return x.num < y.num ;
	}
	return x.pos < y.pos ;
}

int main()
{
	int n,q;
	cin>>n>>q;
	vector<sb> a(q*2);
	for(int i=0;i<q;i++)
	{
		int x,y;
		cin>>x>>y;
		if(x>y)
		{
			int t=x;
			x=y;
			y=t;
		}
		a[i].pos=x-1;
		a[i].num=1;
		a[i+q].pos=y;
		a[i+q].num=-1;
	}
	sort(a.begin() , a.end() ,compare);
	int cnt=a[0].pos;
	int b=0;
	for(int i=0;i<q*2;i++)
	{
		b=b+a[i].num;
		if(b==1&&a[i].num==1&&i>0)
		{
			cnt+=a[i].pos-a[i-1].pos;
		}
	}
	cnt+=n-a[2*q-1].pos;
	cout<<cnt+1;
 }

3bba9a30e9304b5f86bb137aa32eb0ec.jpeg

 输入n个数，有m区间可以缓存，求需要存多少

#include<iostream>

using namespace std;

int main()
{
	int n,m,cnt=0;
	cin>>n>>m;
	int v[n],a[n];
	for(int i=0;i<n;i++)
	{
		int x;
		cin>>x;
		if(v[x]==1)
		{
			continue;
		}
		a[cnt++]=x;
		v[x]=1;
		if(cnt>m)
		{
			v[a[cnt-m-1]]==0;
		}
	}
	cout<<cnt;
}

追逐法/双指针法/尺量法/蚯蚓法：一缩一进

#include<iostream>
#include <algorithm>
using namespace std;

int main()
{
	int n,s;
	cin>>n>>s;
	int a[n];
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	int len=n+1,r=0;
	int sum=0;
	for(int l=0;l<n;l++)
	{
		while(r<n&&sum<s)
		{
			sum+=a[r];
			r++;
		}
		if(sum>=s)
		{
			len=min(r-l,len);
		}
		else
		{
			break;
		}
		sum-=a[l];
	}
	if(len>n)
	{
		printf("0");
	}
	else
	{
		printf("%d",len);
	}
	return 0;
}

计算n个数，i到j最大差值

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main()
{
    int n, maxx = 0;
    cin >> n;
    vector<int> a(n), minn(n);

    for (int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }

    minn[n - 1] = a[n - 1];

    for (int j = n - 2; j >= 0; j--)
    {
        minn[j] = min(minn[j + 1], a[j]);
    }

    for (int i = 0; i < n; i++)
    {
        maxx = max(maxx, a[i] - minn[i]);
    }

    cout << maxx;

    return 0;
}

拼数：将n个数组装成最大数

字符串x+y就是例如233+2331=2332331这样，叠加起来

然后比较就是从头开始一个字符一个比

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

bool comp(string x,string y)
{
	return x+y>y+x;
}

int main()
{
    int n;
	cin>>n;
	vector<string> a(n);
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	sort(a.begin(),a.end(),comp);
	for(int i=0;i<n;i++)
	{
		cout<<a[i];
	}
}

长度为m，数字总和为s的最大值和最小值

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

int main()
{
    int m,s;
	cin>>m>>s;
	if(9*m<s||s<2)
	{
		return 0;
	}
	int qian=0;
	int zhong=s/9;
	if(zhong)
	{
		qian=s%9;
	}
	else
	{
		zhong=s;
	}
	const string a(qian, '9');
	const string b(m-qian-1, '0');
	const string c(m-qian-2, '0');
	cout<<"最大值:"<<a<<zhong<<b<<endl;
	cout<<"最小值:"<<'1'<<c<<zhong-1<<a;
}

国王左手右手金币         比较前后两个a，b来反映全局         "以偏概全"

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

struct lr
{
	int l,r;
};

bool comp(lr x,lr y)
{
	return x.l * x.r < y.l * y.r;
}

int main()
{
	int n;
	cin>>n;
	vector<lr> mult(n);
	for(int i=0;i<n;i++)
	{
		scanf("%d%d",&mult[i].l,&mult[i].r);
	}
	sort(mult.begin(),mult.end(),comp);
	long int maxx=0;
	long int sum=1;
	for(int i=0;i<n;i++)
	{
		sum=mult[i].l*sum;
		maxx=max(maxx,sum/(mult[i].r));//注意类型 
	}
	cout<<maxx;
 }

fed27dd88e56465e8751f787f926327a.jpeg

由此处开始递归

我认为递归不要去想太多，直接以偏概全，用片面的想法去循环

归并排序--一分为二

#include <iostream>

using namespace std;

int n;
int a[1000],b[1000];

void hen(int l,int mid,int r)
{
	int q=l,p=mid+1;
	for(int i=l;i<=r;i++)
	{
		if(q>mid||(a[p]<=a[q]&&p<=r))
		{
			b[i]=a[p++];
		}
		else
		{
			b[i]=a[q++];
		}
	}
	for(int i=l;i<=r;i++)
	{
		a[i]=b[i];
	}
}

void erfen(int l,int r)
{
	if(l==r) return ;
	int mid=(l+r)/2;
	erfen(l,mid);
	erfen(mid+1,r);
	hen(l,mid,r);
}

int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	erfen(0,n-1);
	for(int i=0;i<n;i++)
	{
		cout<<a[i]<<" ";
	}
}

7db858a361c4486ba7ea0bfc4dd55e2a.jpeg

计算逆序对    修改上面代码

void hen(int l, int mid, int r)
{
    int q = l, p = mid + 1;
    for (int i = l; i <= r; i++)
    {
        if (q > mid || (a[p] <= a[q] && p <= r))
        {
            b[i] = a[p++];
            cnt += (mid - q + 1); // 更新逆序对的数量
        }
        else
        {
            b[i] = a[q++];
        }
    }
    for (int i = l; i <= r; i++)
    {
        a[i] = b[i];
    }
}

汉诺塔新解：这次就是按照上面我所说的直接列出来 

#include<iostream>

using namespace std;

int cnt=0;

void han(int n,char qi,char mo,char zhong)
{
	if(n==0) return ;
	han(n-1,qi,zhong,mo);//
	cout<<qi<<"->"<<mo<<endl;
	cnt++;
	han(n-1,zhong,mo,qi);
}

int main()
{
	int n;scanf("%d",&n);
	han(n,'x','z','y');
	cout<<cnt;
}

递归计算器

#include <iostream>
#include <cstdlib>  // 包含 std::atof 函数的头文件
#include <cmath>
using namespace std;

string a;

double zhuan(int l, int r)
{
    string num_str(a.begin() + l, a.begin() + r);
    return std::atof(num_str.c_str());
}

double suan(int l,int r)
{
	int cnt=0;
	int pos1=-1,pos2=-1,pos3=-1;
	for(int i=l;i<r;i++)
	{
		if(a[i]=='(') cnt++;
		if(a[i]==')') cnt--;
		if(cnt==0)
		{
			if(a[i]=='+'||a[i]=='-') pos1=i;
			else if(a[i]=='*'||a[i]=='/') pos2=i;
			else if(a[i]=='^') pos3=i;
		}
	}
	if(pos1==-1&&pos2==-1&&pos3==-1)
	{
		if(cnt==0&&a[l]=='(') return suan(l+1,r-1);
		else if(cnt<0&&a[r]==')') return suan(l,r-1);
		else if(cnt>0&&a[l]=='(') return suan(l+1,r);
		return zhuan(l,r);
	}
	if(pos1!=-1)
	{
		if(a[pos1]=='+') return suan(l,pos1) + suan(pos1+1,r);
		else return suan(l,pos1) - suan(pos1+1,r);
	}
	else if(pos2!=-1)
	{
		if(a[pos2]=='*') return suan(l,pos2) * suan(pos2+1,r);
		else return suan(l,pos2) / suan(pos2+1,r);
	}
	else if(pos3!=-1)
	{
		return pow(suan(l,pos3),suan(pos3+1,r));
	}
}

int main()
{
	cin>>a;
	int len=a.size();
	cout<<suan(0,len);
}

 上面代码前部分的字符串转换数字也可以这样

double zhuan(int l,int r)
{
	double num=0;
	int i=l;
	for(;i<r;i++)
	{
		if(a[i]!='.')
		{
			num = num*10 + a[i] - '0';
		}
		else
		{
			i++;
			break;
		}
	}
	double d=0.1;
	for(;i<r;i++)
	{
		num = num + (a[i] - '0')*d;
		d*=0.1;
	}
	return num;
}

n行四列数，随机总和为0

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

const int N = 4000;
int n, a[4][N];
 

void pre(vector<int>& p, int x, int y)
{
    int cnt = 0;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            p[++cnt] = a[x][i] + a[y][j];
        }
    }
}

int main()
{
    cin >> n;
    for(int i=0; i<n; i++)
    {
        cin >> a[0][i] >> a[1][i] >> a[2][i] >> a[3][i];
    }
    
    n *= n;
	vector<int> q(n), p(n);
	pre(p, 0, 1);
    pre(q, 2, 3);
    sort(q.begin(), q.end());

    int cnt = 0;
    
    for(int i=0; i<n; i++)
    {
        cnt += upper_bound(q.begin(), q.end(), -p[i]) - lower_bound(q.begin(), q.end(), -p[i]);
    }

    cout << cnt << endl;

    return 0;
}
  • lower_bound(q.begin(), q.end(), -p[i])：在有序序列 q 中查找第一个大于或等于 -p[i] 的元素，返回该元素的迭代器。
  • upper_bound(q.begin(), q.end(), -p[i])：在有序序列 q 中查找第一个大于 -p[i] 的元素，返回该元素的迭代器。
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main() {
    int arr[] = {1, 2, 2, 3, 3, 3, 4, 5, 6, 6};
    vector<int> vec(arr, arr + sizeof(arr) / sizeof(arr[0]));

    vector<int>::iterator lower = lower_bound(vec.begin(), vec.end(), 3);
    vector<int>::iterator upper = upper_bound(vec.begin(), vec.end(), 3);

    cout << "Lower bound index: " << lower - vec.begin() << endl; // 输出 3，即第一个 3 的位置
    cout << "Upper bound index: " << upper - vec.begin() << endl; // 输出 6，即最后一个 3 的下一个位置
    cout << "Number of 3s: " << upper - lower << endl; // 输出 3，即元素 3 的个数

    return 0;
}

二分法：空教室分配

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

struct jiao
{
    int a,b,d;
};
int n,m;
vector<jiao> s(1000);
int r[1000],delat[1000];

bool judge(int x)
{
    for(int i=0;i<n;i++)
    {
        if(i==0)
        {
            delat[i]=r[i];
        }
        else
        {
            delat[i]=r[i]-r[i-1];
        }
    }
    for(int i=0;i<x;i++)
    {
        delat[s[i].a+1]-=s[i].d;
        delat[s[i].b+1]+=s[i].d;
    }
    int sum=0;
    for(int i=0;i<n;i++)
    {
    	sum+=delat[i];
    	if(sum<0) return 0;
	}
}

int main()
{
	cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        scanf("%d",&r[i]);
    }
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&s[i].d,&s[i].a,&s[i].b);
    }
    int l=0,r=m;
    while(l<r)
    {
        int mid=(l+r)/2;
        if(judge(mid)) l=mid+1;
        else r=mid;
    }
    if(l==m) cout<<0;
    else cout<<"-1\n"<<l;
}

烘干机

#include <iostream>
#include<algorithm>
#include<cmath>
using namespace std;

int n, k;
int a[1000];

bool judge(int x)
{
    int cnt = 0,t=upper_bound(a,a+n,x) - a;
    for (int i = t; i < n; i++)
    {
		cnt += ceil((a[i] - x)/double(k - 1));//这里的k-1是为了节省完整一件衣服的时间 
    }
    return cnt <= x;
}

int main()
{
    cin >> n >> k;
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    sort(a,a+n);
    int l = 1, r = 2e9;
    while (l < r)
    {
        int mid = l+r >> 1;
        if (judge(mid))
            r = mid;
        else
            l = mid + 1;
    }
    cout << l;
}

Error_Fe
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
分治算法C++
weixin_53235736的博客
03-23 1077
整数划分 整数划分是分治的应用 题目 将正整数nnn表示成一系列正整数之和。n=n1+n2+⋅⋅⋅+nk(n1≥n2≥⋅⋅⋅≥nk≥1,k≥1)n=n_1+n_2+···+n_k(n_1\geq n_2\geq···\geq n_k\geq 1,k\geq 1)n=n1​+n2​+⋅⋅⋅+nk​(n1​≥n2​≥⋅⋅⋅≥nk​≥1,k≥1)。正整数n的这种表示称为正整数的划分。 问有多少中不同的划分方法 输入 第一行输入一个整数nnn 输出 输入划分方法的总数 解析 通过题目可知，一个整数nnn可以有很多种
算法题01C++
qq_41519666的博客
09-18 102
算法题01C++ **题目要求：**给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。 思路：以键值对的形式存放nums数组中的整数元素和其对应下标，遍历nums数组查看是否有元素与当前的 元素之和为target，有的话记录两个坐标 (不能重复)并返回。 代码： class Solution { public: v
dijkstra算法C++
m0_72400354的博客
11-07 5144
dijkstra
快速排序算法C++实现（超详细解析！！！！）
热门推荐
weixin_45031801的博客
09-21 8万+
快速排序，其实是一种分治算法，那么在了解快速排序之前，我们先来看看什么是分治算法。在算法设计中，我们引入分而治之的策略，称为分治算法，其本质就是将一个大规模的问题分解为若干个规模较小的相同子问题，分而治之。
分治算法C++详解
m0_54615144的博客
08-01 1922
分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。
数字签名 RSA算法 c++
05-31
包涵三个RSA算法，c++是实现，数字签名的合集，三个独自的程序，可以独自编译运行，VC6.0下编译 包涵三个RSA算法，c++是实现，数字签名的合集，三个独自的程序，可以独自编译运行，VC6.0下编译
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
0基础学算法C++学习
06-19
【标题】：“0基础学算法C++学习” 在学习C++算法时，首先需要了解算法的基本概念。算法是一系列明确的指令，用于解决特定问题或完成特定任务。C++是一种强大的编程语言，特别适合实现算法，因为它提供了丰富的数据...
凸包问题GraHam算法c++实现
11-09
c++实现的GraHam算法，解决凸包问题
鲸鱼优化算法c++代码实现
09-15
鲸鱼优化(Whale Optimization Algorithm, WOA)算法是澳大利亚格里菲斯大学的Mirjalili 等于2016年提出的一种新型的群体智能优化方法，它的思想来源于海洋中座头鲸独有的特殊捕食行为，算法通过鲸鱼包围、气泡攻击...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 866
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 170
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 327
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 252
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 502
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 249
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 903
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 207
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 302
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
fleury算法c++
07-11
Fleury算法是一种用于生成有向无环图（DAG）拓扑排序的算法，它是由Michael O. Rabin和Ken Trucco于1984年提出的。在C++中，Fleury算法的主要步骤可以概括为： 1. **构建边集**：首先，你需要将DAG的所有边表示为邻接列表或邻接矩阵。 2. **选择起始节点**：从任意一个没有入度的节点开始，这个节点称为“活”节点。 3. **选择路径**：对于当前节点，找到尚未访问过的相邻节点中最短的那个，添加到已排序的序列中，并减少该节点的出度。如果所有邻居都被访问过，可以选择下一个未处理的“活”节点继续。 4. **检查终止条件**：当所有节点都被加入排序序列或者找不到新的路径时，说明已经完成了对DAG的拓扑排序。 5. **重复直到结束**：如果所有节点都通过上述过程处理过了，那么就得到了一个有效的拓扑顺序。如果没有完成，则可能存在环，此时Fleury算法无法得到正确的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值