【冲刺蓝桥杯】背水一战

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量237 收藏 1
点赞数 1
分类专栏： 蓝桥杯 文章标签： eclipse java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52115728/article/details/123932912
版权
本文深入探讨了算法在解决实际问题中的应用，包括动态规划在跳跃游戏、路径寻找和分考场问题中的实现，以及并查集在合根植物与城邦问题中的应用。此外，还介绍了二分查找技巧和整数分解的解决方案。通过这些实例，展示了如何利用算法高效地解决复杂问题。
摘要由CSDN通过智能技术生成

1.算式问题（模拟）

题目链接

public class Main {   
    public static int f(int i,int j,int k)
    {
    	 int []v=new int [10];
    	 for(int l=0;l<10;l++)
    		 v[l]=0;
    	 v[0]=1;//这里因为会遇到有0的情况（如307）
    	while(i>0)
    	{
    		if(v[i%10]==1) return 0;
            else v[i%10]=1;

            if(v[j%10]==1) return 0;
            else v[j%10]=1  ;


            if(v[k%10]==1) return 0;
            else v[k%10]=1  ;
    		i/=10;
    		j/=10;
    		k/=10;
    	}
    	return 1;
    }
   int []v=new int [1000];
	public static void main(String[] args) 
	{
	   Scanner cin=new Scanner (System.in);
	   int sum=0;
	   for(int i=123;i<=987;i++)
	   {
		   for(int j=123;j<=987-i;j++)
		   {
			   int k=i+j;
			   if(f(i,j,k)==1)
			 sum++;
		   }
	   }
	   System.out.print(sum);
	}
}

2. 跳跃的小明（动态规划）

跳跃的小明


import java.math.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.HashSet;
import java.util. Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {   
  
	public static void main(String[] args) 
	{
	   Scanner cin=new Scanner (System.in);
	   int n,p,t;
	   n=cin.nextInt();
	   p=cin.nextInt();
	   t=cin.nextInt();
	   int []arr=new int [2500];
	   int [][]dp=new int [2500][2500];//dp[i][j]:一共跳了j次到达了第i格
	   for(int i=1;i<=n;i++)
		   {arr[i]=cin.nextInt();}
       for(int []a:dp)//memset
       {
	   Arrays.fill(a,-0x3f3f3f);
       }
       for(int i=1;i<=n+1&&i<=p;i++)//p的最小值是1，因此是i<=n+1;i<=n+1&&i<=p是因为p可能大于n
    	   dp[i][1]=arr[i];
 /*第i格*/      for(int i=1;i<=n+1;i++)
       {
 /*走的步数*/   	   for(int j=2;j<=t;j++)
    	   {
 /*上一个走了k步到达第i格*/   		   for(int k=1;k<=p&&k<i;k++)
    		   {
    			   dp[i][j]=Math.max(dp[i][j], dp[i-k][j-1]+arr[i]);
    		   }
    	   }
       }
          System.out.print(dp[n+1][t]);
	}
}

3. 路径（动态规划）

路径

import java.math.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.HashSet;
import java.util. Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {   
  
	 public static int gcd(int a,int b)
	    {
	        if(b==0) return a;
	        else return gcd(b,a%b);
	    }
	    public static int lcs(int a,int b)
	    {
	        return a/gcd(a,b)*b;
	    }
	    public static void main(String[] args)  
	    {     
	       Scanner cin=new Scanner(System.in);  
	       int dp[]=new int [200000];
	       
	     for(int i=1;i<=2021;i++)
	    {
	        for(int j=i+1;j<=i+21;j++)
	        {
	            if(j>2021) break;
	            if(dp[j]==0) dp[j]=dp[i]+lcs(i,j);//这一步很细节
	            dp[j]=Math.min(dp[j], dp[i]+lcs(i,j));
	        }
	    }
	    System.out.print(dp[2021]);
	}
}

4. 分考场（dfs）

import java.util.*;
 
public class Main {
    static int n,m,N=110;
    static List<Integer>[] list=new ArrayList[N];
    static int ans=100;
    static boolean[][] map=new boolean[N][N];
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        for (int i = 0; i < m; i++) {
            int a=sc.nextInt();
            int b=sc.nextInt();
            map[a][b]=map[b][a]=true;
        }
        for (int i = 1; i<=n ; i++) {
            list[i]=new ArrayList<>();
        }
        dfs(1,0);
        System.out.println(ans);
    }
    //st是学生，cl是教室数量
    static void dfs(int st,int cl){
        //这步是剪枝操作，很重要，否则可能导致超时
        //当我们判断已用教室已经大于等于找到的最小情况
        //那我们没有必须继续搜索，因为它一定不是答案
        if (cl>=ans) return;
        //到这一步说明找到了一种更小的方案
        if (st>n){
            ans=cl;
            return;
        }
        for (int i = 1;i<=cl ; i++) {
            int j=0;
            for (;j<list[i].size();++j){
                if(map[st][list[i].get(j)]) break;
            }
            //说明和这个教室全部学生都不相等
            if (j==list[i].size()){
                //放入学生
                list[i].add(st);                
                dfs(st+1,cl);
                //回溯
                list[i].remove(list[i].size()-1);
            }
        }
        //走到这步还没找到教室说明需要新教室
        list[cl+1].add(st);
        dfs(st+1,cl+1);
        //回溯
        list[cl+1].remove(list[cl+1].size()-1);
    }
}

4. 二分答案

1.最大化最小值（靠左查找）

	while (l < r)
    {
        int mid = l + r >> 1;	//(l+r)/2
        if (check(mid))  r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }

2.最小值的最大（靠右查找）

	while (l < r)
    {
        int mid = l + r + 1 >> 1;	//(l+r+1)/2
        if (check(mid))  l = mid;
        else r = mid - 1;
    }

3.浮点二分

	while(r-l>1e-5) //需要一个精度保证，看题意
	{
		double mid = (l+r)/2;
		if(check(mid)) l=mid; //或r=mid;
		else r=mid; //或l=mid;
	}

至于check函数中的判断语句怎么写，先判断是哪个模板，之后看对应if（…）右边的是r还是l，如果是r则说明找大的
打包（二分答案）

 
import java.util.Scanner;
 
public class Main {
	static int N=100010;
	static int[] arr=new int[N];
	static int n,m;
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();
		m=sc.nextInt();
		int max=0;
		int sum=0;
		for(int i=1;i<=n;++i) {
			arr[i]=sc.nextInt();
			sum+=arr[i];
			max=Math.max(max, arr[i]);
		}
		int l=max;
		int r=sum;
		while(l<r) {
			int mid=(l+r)>>1;
			if(check(mid)) r=mid;
			else l=mid+1;
		}
		System.out.println(l);
	}
	static boolean check(int target) {
		int count=0;
		int tmp=0;
		for(int i=1;i<=n;++i) {
			count+=arr[i];
			if(count>target){
				count=0;
				tmp++;
				i--;
			}else if(i==n){
				tmp++;
			}
		}
		return tmp<=m;
	}
}

5. 合根植物（并查集）

并查集模板

合根植物

import java.util.Scanner;
public class Main {
	static int N=1010;
	static int[][] arr=new int[N][N];
	//并查集
	static int[] p=new int[N*N];
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		
		int count=m*n;
		for(int i=1;i<=n*m;++i) p[i]=i;
		int k=sc.nextInt();
		while(k-->0) {
			int a=sc.nextInt();
			int b=sc.nextInt();
			int root1=find(a);
			int root2=find(b);
			if(root1!=root2){
				p[root1]=root2;
				count--;
			}
		}
		System.out.println(count);
	}
	
	static int find(int x) {
		if(x!=p[x]) p[x]=find(p[x]);
		return p[x];
	}
}

5. 汉诺塔

6. 整数分解（dp）

整数分解

/*https://www.luogu.com.cn/paste/miyd5na7*/
package zkj;
import java.math.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.HashSet;
import java.util. Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

 
public class Zz {   
        
    public static void main(String[] args) 
	{  
      Scanner cin=new Scanner (System.in);
      long [][]dp=new long[2500][2500];
      for(long []a: dp)
      {
    	  Arrays.sort(a);
      }
      for(int i=1;i<=2021;i++)
      {
    	  dp[1][i]=1;
      }
      for(int i=2;i<=5;i++)
      {
    	  for(int j=1;j<=2021;j++)
    	  {
    		  for(int k=1;k<=2021;k++)
    		  {
    			  if(j-k>0)
    			  dp[i][j]+=dp[i-1][j-k];
    		  }
    	  }
      }
      System.out.print(dp[5][2021]);
      
	}	
}

7. 城邦（并查集+Kruskal）

Kruskal：对边贪心最小生成树

class node 
{
	int a,b,c;
}
class mycompare implements Comparator<node>{
	public int compare(node x,node y)
	{
		return x.c-y.c;
	}
}
public class Zz {   

	static int n=2021;
	static node []e=new node [n*n];
	static int father[]=new int [2023];
	static int find(int x)
	{
		if(x!=father[x]) 
		{
			father[x]=find(father[x]);
		}
		return father[x];
	}
	static int get(int i,int j)
	{
		int res=0;
		int maxn=Math.max(i,j);
		while(maxn>0)
		{
			int aa=i%10;
			int bb=j%10;
			if(aa!=bb)
			{
				res+=aa+bb;
			}
			i/=10;
			j/=10;
			maxn/=10;
		}
		return res;
	}
    public static void main(String[] args) 
	{  
      Scanner cin=new Scanner (System.in);
      for(int i=1;i<=2021;i++)
    	  father[i]=i;
      int m=0;
      for(int i=1;i<=2021;i++)
      {
    	  for(int j=1;j<=2021;j++)
    	  {
    		  e[m]=new node();
    		  e[m].a=i;
    		  e[m].b=j;
    		  e[m].c=get(i,j);
    		  m++;
    	  }
      }
      
      Arrays.sort(e,0,m,new mycompare());
      long res=0;
      for(int i=0;i<m;i++)
      {
    	  int x=e[i].a;
    	  int y=e[i].b;
    	  int z=e[i].c;
    	  if(find(x)!=find(y))
    	  {
    		  res+=e[i].c;
    		  father[find(x)]=find(y);
    	  }
      }
      System.out.print(res);
	}	
}

8.最短路（Floyd+临接矩阵）

void floyd()
{
    for (int k = 1; k <= n; k ++ ) //通过n个点
        for (int i = 1; i <= n; i ++ ) // 遍历所有点对。
            for (int j = 1; j <= n; j ++ )
                arr[i][j] = min(arr[i][j], arr[i][k] + arr[k][j]);
}

9.递增三元组（暴力）

#include<iostream>
#include<algorithm>
using namespace std;
int a[100005],b[100005],c[100005];
typedef long long ll;
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
	   cin>>a[i];
	for(int i=0;i<n;i++)
	   cin>>b[i];
	for(int i=0;i<n;i++)
	   cin>>c[i];
	sort(a,a+n);
	sort(b,b+n);
	sort(c,c+n);
	int p1=0,p2=0;
	ll sum=0;
	for(int i=0;i<n;i++)
	{
		while(p1<n&&a[p1]<b[i]) p1++;
		while(p2<n&&c[p2]<=b[i]) p2++;
		sum+=(ll)p1*(n-p2);
	 } 
	cout<<sum<<endl;
	return 0;
}

总结

1.二维数组的初始化任何值，其中下面的dp数组是我们要初始化的对象，

int [][]dp=new int [25][25];
 for(int []a:dp)//memset
       {
	   Arrays.fill(a,-0x3f3f3f);
       }

2.二维vector的使用

ArrayList<Integer>list[]=new ArrayList[100];
for(int i=1;i<=n;i++)
{
   list[i]=new ArrayList();
}

3.二分答案套模板
4.dp模板

import java.math.*;
import java.util.*;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Scanner cin=new Scanner(System.in);
      int n;
      int []a=new int [50];
      int []dp=new int [50];
      int maxn=-9999;
      n=cin.nextInt();
      for(int i=1;i<=n;i++)
      { a[i]=cin.nextInt();  dp[i]=a[i];}
      /*for(int i=1;i<=n;i++)
      {
    	  dp[i]=1;
    	  for(int j=1;j<i;j++)
    	  {
    		  if(a[i]>a[j])
    		  dp[i]=Math.max(dp[i], dp[j]+1);
    	  }
 	  maxn=Math.max(dp[i], maxn);
      }*/
      for(int i=1;i<=n;i++)
      {
    	  dp[i]=Math.max(dp[i], dp[i-1]+a[i]);
      }
      for(int i=1;i<=n;i++) maxn=Math.max(maxn, dp[i]);
      System.out.print(maxn);
	}

}

/*#include<bits/stdc++.h>
using namespace std;
//求最小全装满的方案数
int a[250];
int dp[250];
const int maxn=0x3f3f3f;
int main()
{

//cin>>n>>sum;
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++)
    cin>>a[i];
dp[0]=0;
for(int i=1;i<=m+1;i++)
    dp[i]=maxn;
for(int i=1;i<=n;i++)
{

    for(int j=a[i];j<=m;j++)
    {

        dp[j]=min(dp[j],dp[j-a[i]]+1);
    }
}
cout<<dp[m];
}
*/
#include<bits/stdc++.h>
using namespace std;
//求最大全装满的方案数
int a[250];
int dp[250];
const int maxn=0x3f3f3f;
int main()
{

//cin>>n>>sum;
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++)
    cin>>a[i];
dp[0]=0;
for(int i=1;i<=m+1;i++)
    dp[i]=-maxn;
for(int i=1;i<=n;i++)
{

    for(int j=m;j>=a[i];j--)
    {

        dp[j]=max(dp[j],dp[j-a[i]]+1);
    }
}
cout<<dp[m];
}


#include<bits/stdc++.h>
#include<iostream>
#include<cstring>
using namespace std;
int n,m;//itn dp[m][n]
int dp[500][500];
int main(){

cin>>n>>m;
dp[0][0]=1;
for(int i=1;i<=m;i++)
{
    for(int j=0;j<=n;j++)
{
    if(j-i>=0)
    {
        dp[i][j]=dp[i-1][j]+dp[i][j-i];
    }
    else {
        dp[i][j]=dp[i-1][j];
    }
}
}
cout<<dp[m][n];

}
沉梦昂志️
关注
专栏目录
蓝桥杯试题 基础练习 BASIC-9 特殊回文数——冲刺蓝桥杯第五天
12-22
import java.util.ArrayList; import java.util.Scanner; public class SpecialPalindrome { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt();...
蓝桥杯2省赛无忧班和冲刺班笔记
03-30
【蓝桥杯省赛无忧班与冲刺班笔记详解】 蓝桥杯是一项国内知名的软件和信息技术专业人才的竞赛，旨在培养和选拔优秀的编程及算法能力。该赛事覆盖了大学本科、研究生以及初高中等多个层次，为广大学子提供了一个展示...
冲刺蓝桥杯day1
weixin_73052370的博客
02-28 196
枚举顺序：按给定的时间范围进行枚举，将日期转化为8位数字（总的时间复杂度小于10e7，而且也保证了从小到大的顺序）本想着用BFS发现要判断的条件太多，较为复杂；还是能用暴力枚举就暴力枚举！判断是否为可能的表示。
一周冲刺蓝桥杯：闰年判断
FB_ory的博客
04-05 237
一周冲刺蓝桥杯。
蓝桥杯冲刺 Day5
weixin_61383086的博客
03-12 492
猴子分香蕉一看就会的题解
7天冲刺蓝桥杯计算思维U12备考题册及答案
小码农的博客
01-28 167
【冲刺蓝桥杯的最后30天】day7
想要慢慢变得优秀的向阳的博客
03-10 874
蓝桥杯最后29天冲刺省一！！！
蓝桥杯十天冲刺计划
只想和你一起进步
03-30 2406
蓝桥杯倒计时十天冲刺计划，一起冲冲冲
一星期冲刺蓝桥杯备赛题单及详解
HARDWORKING SURELY PAYS OFF
04-03 1492
一星期冲刺蓝桥杯备赛题单及详解 说明： 选用平台：leetcode 选用语言：c++ 题单 day1：基础题，无数据结构 leetcode-简单题：70. 爬楼梯 - 力扣（LeetCode） (leetcode-cn.com) leetcode-简单题：剑指 Offer 10- I. 斐波那契数列 - 力扣（LeetCode） (leetcode-cn.com) leetcode-简单题：1. 两数之和 - 力扣（LeetCode） (leetcode-cn.com) leetcode-简单题：88.
冲刺蓝桥杯Java b组——合并区域（DFS深度优先）
weixin_73161549的博客
02-09 2237
蓝桥杯第十四届java b组第五题——合并区域（DFS解法）
1个月0基础冲刺蓝桥杯（0）
weixin_59489005的博客
03-04 698
第0天的学习内容：C/C++必要语法，冲哇冲哇
【冲刺蓝桥杯的最后30天】day3
想要慢慢变得优秀的向阳的博客
03-06 715
备战蓝桥杯冲刺省一30天
蓝桥杯单片机客观题汇总和赛前代码冲刺
04-09
在“蓝桥杯单片机客观题汇总和赛前代码冲刺”这个资源中，我们可以找到对准备参加蓝桥杯单片机竞赛的参赛者来说极其宝贵的信息。蓝桥杯是一项全国性的专业技能比赛，旨在检验并提升大学生在计算机科学，尤其是嵌入式...
蓝桥杯编程猫Kitten模拟试题二模拟题附答案
04-13
### 蓝桥杯编程猫Kitten模拟试题二知识点解析 #### 一、蓝桥杯简介与背景 蓝桥杯是一项面向全国高等院校在校大学生的IT技术竞赛，旨在培养学生的创新能力及实践能力。其中，“编程猫Kitten”是针对低龄段儿童设计...
Hadoop集群的高可用（HA）：NameNode和resourcemanager高可用的搭建
lzhlizihang的博客
09-30 1061
HA的搭建
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 243
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 471
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 568
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 569
spring boot 整合 mybatis
2020蓝桥杯C++省赛冲刺指南及策略
本资源是一份名为“C++复习手册 6.8.docx”的文档，针对的是2020年第六届蓝桥杯省赛的复习材料。这份复习资料旨在帮助考生巩固和复习C++知识，解决他们在备考过程中遇到的常见错误和难题。复习手册强调了以下几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沉梦昂志️

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值