11111

最新推荐文章于 2022-12-30 22:46:37 发布
最新推荐文章于 2022-12-30 22:46:37 发布
阅读量542 收藏
点赞数
文章标签： 图论 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47589851/article/details/121512641
版权 
//最小生成树
#include<bits/stdc++.h>
using namespace std;
int cmp(Evode a,Evode b){
    return a.lowcost<b.lowcost;
}
int find(char x){
    int y;
    y=int(x)-int('0');
    while(Vexset[y]!=y) y=Vexset[y];
    return y;
}
int add(char x,char y){
    if(find(x)==find(y)){
        return 0;
    }
    else {
        Vexset[find(x)]=find(y);
    }
    return 1;
}
void Kruskal(AMGraph G){
    for(int i=0;i<G.vexnum;i++){
        Vexset[int(G.vexs[i])-int('0')]=int(G.vexs[i])-int('0');
    }
    sort(Edge,Edge+G.arcnum,cmp);
    for(int i=0;i<G.arcnum;i++){
        if(add(Edge[i].Head,Edge[i].Tail)){
            printf("%c->%c\n",Edge[i].Head,Edge[i].Tail);
        }
    }
}

//快速排序 
#include <stdio.h>
int a[101],n;//定义全局变量，这两个变量需要在子函数中使用
void quicksort(int left, int right) {
	int i, j, t, temp;
	if(left > right)
		return;
    temp = a[left]; //temp中存的就是基准数
    i = left;
    j = right;
    while(i != j) { //顺序很重要，要先从右边开始找
    	while(a[j] >= temp && i < j)
    		j--;
    	while(a[i] <= temp && i < j)//再找左边的
    		i++;       
    	if(i < j)//交换两个数在数组中的位置
    	{
    		t = a[i];
    		a[i] = a[j];
    		a[j] = t;
    	}
    }
    //最终将基准数归位
    a[left] = a[i];
    a[i] = temp;
    quicksort(left, i-1);//继续处理左边的，这里是一个递归的过程
    quicksort(i+1, right);//继续处理右边的 ，这里是一个递归的过程
}
int main() {
	int i;
    //读入数据
	scanf("%d", &n);
	for(i = 1; i <= n; i++)
		scanf("%d", &a[i]);
    quicksort(1, n); //快速排序调用
    //输出排序后的结果
    for(i = 1; i < n; i++)
    	printf("%d ", a[i]);
    printf("%d\n", a[n]);
    return 0;
}

// 棋盘覆盖问题
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
int title =1;
int a[101][101];
//tr，tc表示棋盘的起始位置(第tr行，第tc列)
//dr，dc表示特殊格子所在位置(第dr行，第dc列)，4*4的棋盘tr，tc取值范围为0,1,2,3
//size表示棋盘大小，4*4的棋盘size为4
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
    if(size==1)  return;
    int s = size/2;
    int t = title++;
    if(dr<tr+s&&dc<tc+s){//左上
        ChessBoard(tr,tc,dr,dc,s);
    }else{
        a[tr+s-1][tc+s-1] = t;
        ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
    }
    if(dr<tr+s&&dc>=tc+s){//右上
        ChessBoard(tr,tc+s,dr,dc,s);
    }else{
        a[tr+s-1][tc+s] = t;
        ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
    }
    if(dr>=tr+s&&dc<tc+s){//左下
        ChessBoard(tr+s,tc,dr,dc,s);
    }else{
        a[tr+s][tc+s-1] = t;
        ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
    }
    if(dr>=tr+s&&dc>=tc+s){//右下
        ChessBoard(tr+s,tc+s,dr,dc,s);
    }else{
        a[tr+s][tc+s] = t;
        ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
    }
}
int main()
{
    int size;
    scanf("%d",&size);
    for(int i=0;i<size;i++)
        for(int j=0;j<size;j++)
            a[i][j] = 0;
    int x,y;
    cin>>x>>y;
    ChessBoard(0,0,x,y,size);
    for(int i=0;i<size;i++)
    {
        for(int j=0;j<size;j++)
            printf("%-5d",a[i][j]);
        printf("\n");
    }
    return 0;
}


// 活动选择问题
#include<iostream>
#include<stdio.h>
#include <vector>
#include <algorithm>

using namespace std;

struct movie {
	int start, end;
};

int cmp(movie a, movie b) {
	return a.end < b.end;
}

int main() {
	int n;
		cin >> n;
		vector<movie> arr(n);
		for (int i = 0; i < n; i++) {
			cin >> arr[i].start >> arr[i].end;//输入开始时间和结束时间
		}
		sort(arr.begin(), arr.end(), cmp);//按结束时间从小到大排序
		int end = arr[0].end;//取第一个活动的结束时间
		int sum = 1;//第一个活动一定能放完
		for (int i = 1; i < n; i++) {
			if (arr[i].start < end) {
				continue;//开始时间小于上个活动结束时间的活动不符合要求，跳过
			}
			end = arr[i].end;//更新结束时间
			sum++;
		}
		cout << sum << endl;
	
	return 0;
}

//最小生成树-kruskal
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
struct Edge
{
    int x,y,z;
}a[1000010]; //存储x,y,z的信息
bool cmp(const Edge &a,const Edge &b)//比较大小
{
        return a.z<b.z;
}
int n,m;
int tree[1000010];//建造森林,初始时每个点就是一棵树
int findfather(int x)
{
    if(tree[x]!=x)
        return tree[x]=findfather(tree[x]);  //并查集,更新父节点,减少了一些多于查找,使得查询速度更快
    return tree[x];
}
int kruskal(struct Edge a[],int N,int M)
{
    sort(a,a+m,cmp);//先将给定的数据进行排序,边短的排在前面，长的在后。
    for(int i=1; i<=N; i++)
        tree[i]=i;//每棵树的父节点是自己
    int sum=0;
    for(int i=0; i<M; i++)
    {
        int x=a[i].x;
        int y=a[i].y;
        int z=a[i].z;
        if(findfather(x)!=findfather(y))//判断两个是否在同一颗树中,不在同一棵树时才将该树加入
        {
            tree[findfather(x)]=findfather(y);//加入树
            sum+=z;//计算长度
        }
    }
    return sum;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
    printf("%d",kruskal(a,n,m));
    return 0;
}


//最长公共子序列长度
#include<iostream>
#include<string.h>
using namespace std;
int main(){
	string a,b;
	cin>>a>>b;
	int len1=a.size();
	int len2=b.size();
	int dp[len1+1][len2+1];
	memset(dp,0,sizeof(dp));
	for(int i=0;i<len1;i++){
		for(int j=0;j<len2;j++){
			if(a[i]==b[j])
				dp[i+1][j+1]=dp[i][j]+1;
			else
				dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]); 
		}
	}
	cout<<dp[len1][len2];
}

//最短路径之Floyd 
#include<iostream>
#include<cstring>
#include<stdio.h>
using namespace std;
#define MaxVertexNum 100
#define INF 9998
typedef struct
{
    char vertex[MaxVertexNum];
    int edges[MaxVertexNum][MaxVertexNum];
    int n,e;
} MGraph;
void CreateMGraph(MGraph &G,int a[][2])
{
    int i,j,k,p;
    cin>>G.n>>G.e;
    for(i=0; i<G.n; i++)
        G.vertex[i]=i;
    for(i=0; i<G.n; i++)
        for(j=0; j<G.n; j++)
        {
            G.edges[i][j]=INF;
            if(i==j)
                G.edges[i][j]=0;
        }
    for(k=0; k<G.e; k++)
    {
        cin>>i>>j>>p;
        G.edges[i][j]=p;
    }
    for(int i=1; i<=2; i++)
        for(int j=1; j<=2; j++)
            cin>>a[i][j];
}

void Ppath(int path[][MaxVertexNum],int i,int j)
{
    int k;
    k=path[i][j];
    if(k==-1)
        return;
    Ppath(path,i,k);
    printf("%d->",k);
    Ppath(path,k,j);
}
void Dispath(int A[][MaxVertexNum],int path[][MaxVertexNum],int n,int a[][2])
{
    int i;
    for(i=1; i<=2; i++)
    {
        int j=1;
        int m=a[i][j];
        int n=a[i][j+1];
        if(A[m][n]==INF)
        {
            if(m!=n)
                printf("%d->%d:-1\n",m,n);
        }
        else
        {
            printf("%d->",m);
            Ppath(path,m,n);
            printf("%d:%d\n",n,A[m][n]);
        }
    }
}
void bijiao(int A[][MaxVertexNum],MGraph G,int path[][MaxVertexNum])
{
    int max = A[0][0];
    int x=0,y=0;
    for (int i = 0; i < G.n; i++)
        for (int j = 0; j < G.n; j++)
            if (A[i][j]>max&&A[i][j]!=INF)
            {
                max = A[i][j];
                x=i;
                y=j;
            }
    printf("%d->",x);
    Ppath(path,x,y);
    printf("%d:%d",y,A[x][y]);
}

void Floyd(MGraph G,int a[][2])
{
    int i,j,k;
    int A[MaxVertexNum][MaxVertexNum];
    int path[MaxVertexNum][MaxVertexNum];
    for(i=0; i<G.n; i++)
        for(j=0; j<G.n; j++)
        {
            A[i][j]=G.edges[i][j];
            path[i][j]=-1;
        }
    for(k=0; k<G.n; k++)
        for(i=0; i<G.n; i++)
            for(j=0; j<G.n; j++)
                if(A[i][j]>A[i][k]+A[k][j])
                {
                    A[i][j]=A[i][k]+A[k][j];
                    path[i][j]=k;
                }
    Dispath(A,path,G.n,a);
    bijiao(A,G,path);
}
int main()
{
    MGraph G;
    int a[2][2];
    CreateMGraph(G,a);
    Floyd(G,a);
    return 0;
}

//图着色问题 
#include<iostream>
#include<string.h>
#include<set>
#include<vector>
using namespace std;
int main()
{
    int v,e,k;
    cin>>v>>e>>k;
    int v1,v2;
    vector<int>vec[v];
    for(int i=0; i<e; i++)
    {
        cin>>v1>>v2;
        vec[v1-1].push_back(v2-1);
        vec[v2-1].push_back(v1-1);
    }
    int t;
    cin>>t;
    while(t--)
    {
        bool flag=true;
        set<int>s;
        int color[v];
        for(int i=0; i<v; i++)
        {
            cin>>color[i];
            s.insert(color[i]);
        }
        int len=s.size();
        if(len!=k)
        {
            cout<<"No"<<endl;
            continue;
        }
        vector<int>::iterator it;
        for(int i=0; i<v; i++)
        {
            for(it=vec[i].begin(); it!=vec[i].end(); it++)
            {
                if(color[*it]==color[i])
                {
                    flag=false;
                    break;
                }
            }
            if(!flag)
                break;
        }
        if(flag)
            cout<<"Yes"<<endl;
        else
            cout<<"No"<<endl;
    }
}

//0/1背包问题
#include<iostream>
using namespace std;

int dp[200][200];//前i个物品装入容量为j的背包中获得的最大价值

//0-1背包动态规划算法   构造二维表
int KnapSack(int n, int w[], int v[], int x[], int C) {
	int i, j;

	for (i = 0; i <= n; i++) { // 初始化：背包容量为0时，前i个物品无法装入，获得最大价值为0
		dp[i][0] = 0;

	}
	for (j = 0; j <= C; j++) {	//初始化：物品数量为0时，背包容量j无论多大，获得最大价值为0
		dp[0][j] = 0;
	}
	for (i = 0;i <= n;i++) {
		if (w[i] > C) {
			dp[i][0] = 0;
		}
	}
	for (i = 1; i <= n; i++) {    //构造二维表：行对应前i个物品；列对应背包容量j
		for (j = 1; j <= C; j++) {
			if (j < w[i]) {		//背包容量不够第i个物品的重量大
				dp[i][j] = dp[i - 1][j]; //不装，获得的最大价值仍然等于前i-1个物品装入情况的
			}
			else {				//装，看看是装入后获得的最大价值大还是前i-1个物品装入情况的最大价值大，比较后选择最大的
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
				
			}
		}
	}
	j = C; //j等于背包的最大容量C
	for (i = n; i > 0; i--) {   //从后往前遍历，如果装了第i个物品则标志位x[i]=1
		if (dp[i][j] > dp[i - 1][j]) { //判断第i个物品有没有装进去
			x[i] = 1;		//第i个物品装了进去
			j = j - w[i];	//装了进去就将该物品的重量减去，j为剩余容量
		}
		else {
			x[i] = 0;   //第i个物品没装进去
		}
	}
	for (i = 1; i <= n; i++) {
		if (x[i]==1) {
			cout << i;
			cout << " ";
		}
		
	}	if (dp[n][C] == 0) {
		cout << "No";
		return dp[n][C] = 0;
	}else
		return dp[n][C];
}
int main() {
	int w[100];	//物品的重量
	int v[100];	//物品的价值
	int x[100];	//物品的选取状态
	int i, n, C;
	cin >> n>>C;//物品总数+背包总容量
	for (i = 1; i <= n; i++) {
		cin >> w[i]>>v[i];
	}
	int maxValue = KnapSack(n, w, v, x, C);
	cout << endl;
	cout <<  maxValue << endl;
	return 0;
}

涂涂爱代码
关注
【无标题】11111
csdn_te_Blog_003的博客
05-23 1793
111111
记录11111111
qq_52463974的博客
07-02 61
菜鸟学算法--快速排序
洪源的博客
01-30 1万+
什么是快速排序 快速排序是一种排序方法，通过选择基准值，将样本分为小于基准值+基准值+大于基准值三部分，对于初基准值以外的部分，同样使用选择基准值并划分的方法，快速排序速度大于选择排序，示例如下， 例:对数组[5，3，1，9，7]进行选择排序 第一次分区： 基准值：5 ，小于基准值数组 = []，大于基准值数组 = [] 3&lt;5，小于基准值数组 = [3]，大于基准值数组 = []...
快速排序C++算法
06-15
严奶奶《数据结构》书上快速排序的C++算法实现，随机生成10个100以内的数，然后快速排序，并输出比较次数
快速排序算法（C++，用的其实还是C）
04-10
VC平台，使用C编写，采用二叉树节点模型 水平有限，大虫们莫笑
手撕算法之快速排序
yangyu11111的博客
09-28 378
手撕快排 def quickSort(list1): if len(list1)<1: return list1 else: base = list1[0] left = [e for e in list1[1:] if e<list1[0]] right = [e for e in list1[1:] if e>list...
常用算法-快速排序
davidsu33的专栏
05-09 720
快速排序的原理，设置一个键值，作为比较的当前值，然后找到该值自己所在的位置，这种排序方法，如果键值不同，其排序时间也会存在一定差异，最理想的就是pos值是该排序段范围的中间值，这样可以在算法上缩短排序时间，快速排序从算法上要优于冒泡排序。最近看到网上的快速排序算法有的是错的，就连百度百科上写的也是错误的代码，wiki百科上的还是比较靠谱。鉴于此，我自己重新写了一下，不容易理解的地方我增加了注释。见
JavaSE笔记11111
10-15
JavaSE是Java标准版，是Java编程的基础，涵盖了面向对象编程、集合框架、I/O流、多线程和反射等多个核心知识点。 面向对象是Java的核心特性，它包括三大特征：继承、多态和封装。继承使得子类可以继承父类的属性和...
机房聊天工具11111
10-04
虽然“机房聊天工具11111”这个标题没有提供太多具体信息，我们可以从一般的角度探讨这类工具的重要特性和功能。 首先，机房聊天工具必须具备实时性。在快速响应时间至关重要的IT环境中，即时通讯是必不可少的。这...
splite11111
02-24
本文将深入探讨“splite11111”这一主题，它与解决SVN在处理文件时遇到的问题密切相关，特别是当SVN在提交、检出或清理操作时遇到故障并显示乱码时的解决方案。 首先，我们需要理解SVN的基本工作原理。SVN通过跟踪...
supplier-v2_11111_V2_
10-02
【标题】"supplier-v2_11111_V2_" 暗示这是一个软件项目的版本标识，可能是供应商管理系统的新版本。"V2"表明这是第二版，而"11111"可能是项目代码或者特定版本的编号，具体含义需要结合项目背景来理解。 【描述】...
11111.zip
06-14
很抱歉，根据您提供的信息，标题为"11111.zip"的压缩包文件以及其描述"11111"都缺乏具体的内容或标签来指示任何特定的IT知识点。压缩包子文件的名称同样只有一个"11111"，这也不提供额外的信息。在没有详细的数据、...
百度实时推送工具11111
03-17
【标题】：“百度实时推送工具11111”是一个基于百度搜索引擎的优化工具，它主要功能是帮助网站管理员快速、有效地将网站内容更新或新产生的URL推送给百度搜索引擎，以便于百度能更快地发现并索引这些网页，提高网站...
git11111
02-18
标题"git11111"可能是指一个与Git相关的项目或教程。 在描述中虽然没有具体信息，但我们可以假设这是一个关于使用Git进行Java项目管理的示例。在Java开发环境中，Git可以帮助团队成员各自在独立的分支上工作，然后...
03 快速排序（quick sort）
xuqw11111的专栏
12-30 80
快速排序算法
排序算法之快速排序
热门推荐
青鬆下的ミ坚躯 的个人博客
03-04 1万+
高快省的排序算法 有没有既不浪费空间又可以快一点的排序算法呢？那就是“快速排序”啦！光听这个名字是不是就觉得很高端呢。 假设我们现在对“6  1  2 7  9  3  4  5 10  8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比...
记录一下蓝牙学习
newzhpfree的博客
10-07 192
记录一下蓝牙学习 https://github.com/espressif/esp-aliyun这个是乐鑫的一些无线蓝牙WiFi代码参考 #记录一下蓝牙学习# 学习目标： 提示：这里可以添加学习目标 例如：一周掌握 Java 入门知识 学习 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 时间 1、 周一至周五晚上 7 点—晚上9点 2、 周六上午 9 点-上午 11 点 3、 周日下午 3 点-下午 6 点 1、 技术笔记 2 遍 2、CSDN
数据库存11111还是aaaaa省空间
最新发布
07-11
像"11111"和"aaaaa"这样的连续字符序列，在数据库表中占用的空间取决于它们所使用的数据类型。如果存储为整数类型，"11111"可能会更节省空间，因为可以直接存储数值，而如果是字符串类型，两者长度相同时，存储的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值