接着盘Java，接着写题，还有一场cf

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量342 收藏 1
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72528211/article/details/129602322
版权

目录

包装类

单例设计模式

类的成员——初始化块

final关键字

抽象类

模块设计模式

接口

类的成员——内部类

集合

HashSet集合 

TreeSet集合 

List集合

map集合

工具类conllections

泛型

泛型类 

 泛型接口

报错的情况 

 泛型方法

 泛型通配符

有限制的通配符

cf

包装类

Java有一个非常明显的特点，它有很多类，类中有方法，用户可以通过调用类，来解决问题，与其自己再创造类，学会调用已知的类，效果可能会更好。

 

 

 

 

单例设计模式

 一般new对象太费力，或者需要频繁地new新的但没有必要的对象，就使用单例设计模式。

 

 

 

类的成员——初始化块

 

final关键字

对变量起限制作用

 

 

final修饰的方法不能被子类重写。

 

 

抽象类

abstract关键字

只要类中有一个抽象方法，类就必须是抽象类、

 

 

模块设计模式

抽象类体现的就是一种模块模式的设计，它作为多个子类的通用模板。

 

 

接口

父类一般不要去改，因为一旦改了父类，它下面的子类就会受影响，但是有时候又确实需要对父类扩展方法，一般这种时候就新建接口，然后再在接口上新建方法，其它的子类有类似需求的，也可以新建接口。

通俗点讲就是，父类已经满足不了子类的需求了，那我就要自食其力去创建这个东西，自食其力创建的就是接口。

 

 

 

 

类的成员——内部类

 

集合

HashSet集合 

 

 

 

 

TreeSet集合 

 

 

List集合

 

map集合

 

 ​​​​​

 

 

 

工具类conllections

 ​​​​​​​

 

泛型

让集合添加我指定的类型，从而限制类型，更安全。

泛型类 

 泛型接口

 

报错的情况 

 

 泛型方法

 

 

 泛型通配符

 

有限制的通配符

 

 

 

简单搜索&&进阶搜索 - Virtual Judge 

分析：

这个题目究其本质就是一个全排列，但是要记得回溯。

具体实现就是创建一个二维数组，对可以连接i的每个元素的值都赋1，然后这其实就已经实现了字典序的排列，然后从起点开始找，回到起点就结束，然后输出。

#include<stdio.h>
#include<math.h>
#include<string.h>
int m;
int a[21][21],aa[25];
int b[25];
int k=1;
void dfs(int c,int d)
{
	if(d==20&&!a[c][m])
	return;
	if(d==20&&a[c][m])
	{
		printf("%d:  ",k);
		k++;
		for(int i=0;i<20;i++)
		printf("%d ",aa[i]);
		printf("%d",m);
		printf("\n");
		return;
	}
	for(int i=1;i<=20;i++)
	{
		if(a[i][c]&&!b[i])
		{
			b[i]=1;
			aa[d]=i;
			dfs(i,d+1);
			b[i]=0;
		}
	}
}

int main()
{
	for(int i=1;i<=20;i++)
	{
		int x,y,z;
		scanf("%d%d%d",&x,&y,&z);
		a[i][x]=1;
		a[i][y]=1;
		a[i][z]=1;
	}
	scanf("%d",&m);
	while(m)
	{
		k=1;
		aa[0]=m;
		for(int i=0;i<21;i++)
		b[i]=0;
		b[m]=1;
		dfs(m,1);
		scanf("%d",&m);
	}
}

https://vjudge.net/contest/547627#problem/G

分析：

这个题可以用双向广搜，但是我是用了两次广搜，然后加起来比较找最小。

这里有一个小坑点就是，判断哪个kfc的距离最短的时候，还要判断这两个人是否都能到这个kfc，但凡有一个人没有到，这个kfc都不能作为两个人会面的场所。

还有就是她们两个走过的地方都必须标记并且记录以便于判断。

#include<stdio.h>
#include<math.h>
#include<string.h>
int m,n;
int a[2][201][201],xx,yy,k;
char c[201][201],cc;
int b[201][201];
int d[4][2]={{0,1},{0,-1},{1,0},{-1,0}};

struct fff
{
	int x;
	int y;
	int s;
}map[201*201];

void cz(char ccc)
{
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		if(c[i][j]==ccc)
		{
			xx=i;
			yy=j;
			return;
		}
	}
}

void bfs()
{
	int tail,head;
	tail=head=1;
	cz(cc);
	map[tail].x=xx;
	map[tail].y=yy;
	map[tail].s=0;
	b[xx][yy]=1;
	tail++;
	while(head<tail)
	{
		for(int i=0;i<4;i++)
		{
			int nx=map[head].x+d[i][0];
			int ny=map[head].y+d[i][1];
			if(nx<0||nx>=n||ny<0||ny>=m||b[nx][ny]||c[nx][ny]=='#')
			continue;
			b[nx][ny]=1;
			map[tail].x=nx;
			map[tail].y=ny;
			map[tail].s=map[head].s+1;
			a[k][nx][ny]=map[tail].s;
			tail++;
		}
		head++;
	}
}

void minn()
{
	int min=400000;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			if(c[i][j]=='@'&&a[0][i][j]&&a[1][i][j])
			{
				if(a[0][i][j]+a[1][i][j]<min)
				min=a[0][i][j]+a[1][i][j];
			}
		}
	}
	printf("%d\n",min*11);
}

int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		for(int i=0;i<n;i++)
		scanf("%s",c[i]);
		//for(int i=0;i<n;i++)
		//printf("%s\n",c[i]);
		k=0;
		cc='Y';
		for(int i=0;i<201;i++)
		for(int j=0;j<201;j++)
		b[i][j]=0;
		bfs();
		k=1;
		cc='M';
		for(int i=0;i<201;i++)
		for(int j=0;j<201;j++)
		b[i][j]=0;
		bfs();
		minn();
		for(int z=0;z<2;z++)
		for(int i=0;i<201;i++)
		for(int j=0;j<201;j++)
		a[z][i][j]=0;
	}
}

简单搜索&&进阶搜索 - Virtual Judge

分析：

这个题主打的就是一个记录，记录路径，记录次数。（副主打判断）

我写得有点臃肿，但思路没什么大问题，它还是一个广搜，但是它的结构要多的就是它的记录它之前做的动作，进入循环先判断，是不是达到了要求的水量，达到就输出，根据记录的路径选择性的输出，在搜索时它一共有6个状态，所以对于每一个“head”都要判断六次。

它每一次倒水都要进行记录，记住是每一次，记住这个路径，之后直接输出就行。

这个题没有坑点，但是脑袋一定要清楚，我下面该判断什么，该怎么判断，判断成功怎么赋值，怎么给路径。

#include<stdio.h>
#include<math.h>
#include<string.h>
int a,b,c;
int book[1005][1005];
struct fff
{
    int aa;
    int bb;
    int bs;
    int k;
    char jl[1005];
}arr[1005*1005];

void bfs()
{
    int tail,head;
    head=tail=0;
    arr[tail].aa=0;
    arr[tail].bb=0;
    arr[tail].bs=0;
    book[0][0]=1;
    arr[tail].k=0;
    arr[tail].jl[0]=0;
    tail++;
    while(head<tail)
    {
        struct fff p=arr[head++];
        if(p.aa==c||p.bb==c)
        {
            printf("%d\n",p.bs);
            for(int i=0;i<p.k;i++)
            {
                switch (p.jl[i])
                {
                    case '0':
                    printf("FILL(1)\n");
                    break;
                    case '1':
                    printf("FILL(2)\n");
                    break;
                    case '2':
                    printf("DROP(1)\n");
                    break;
                    case '3':
                    printf("DROP(2)\n");
                    break;
                    case '4':
                    printf("POUR(1,2)\n");
                    break;
                    case '5':
                    printf("POUR(2,1)\n");
                    break;
                }
            }
            return;
        }
        for(int i=0;i<6;i++)
        {
            if(i==0&&!book[a][p.bb])//倒满a
            {
                book[a][p.bb]=1;
                arr[tail].aa=a;
                arr[tail].bb=p.bb;
                arr[tail].bs=p.bs+1;
                strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                tail++;
            }
            if(i==1&&!book[p.aa][b])//倒满b
            {
                book[p.aa][b]=1;
                arr[tail].aa=p.aa;
                arr[tail].bb=b;
                arr[tail].bs=p.bs+1;
                strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                tail++;
            }
            if(i==2&&!book[0][p.bb])//倒掉a
            {
                book[0][p.bb]=1;
                arr[tail].aa=0;
                arr[tail].bb=p.bb;
                arr[tail].bs=p.bs+1;
                strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                tail++;
            }
            if(i==3&&!book[p.aa][0])//倒掉B
            {
                book[p.aa][0]=1;
                arr[tail].aa=p.aa;
                arr[tail].bb=0;
                arr[tail].bs=p.bs+1;
                strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                tail++;
            }
            if(i==4)//把a倒给b
            {
                struct fff q;
                q.bb=p.aa+p.bb;
                if(q.bb<b&&!book[0][q.bb])
                {
                    book[0][q.bb]=1;
                    arr[tail].aa=0;
                    arr[tail].bb=q.bb;
                    arr[tail].bs=p.bs+1;
                    strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                    tail++;
                }
                else if(q.bb>=b&&!book[q.bb-b][b])
                {
                    book[q.bb-b][b]=1;
                    arr[tail].aa=q.bb-b;
                    arr[tail].bb=b;
                    arr[tail].bs=p.bs+1;
                    strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                    tail++;
                }
            }
             if(i==5)//把b倒给a
            {
                struct fff q;
                q.aa=p.aa+p.bb;
                if(q.aa<a&&!book[q.aa][0])
                {
                    book[q.aa][0]=1;
                    arr[tail].aa=q.aa;
                    arr[tail].bb=0;
                    arr[tail].bs=p.bs+1;
                    strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                    tail++;
                }
                else if(q.aa>=a&&!book[a][q.aa-a])
                {
                    book[a][q.aa-a]=1;
                    arr[tail].aa=a;
                    arr[tail].bb=q.aa-a;
                    arr[tail].bs=p.bs+1;
                    strcpy(arr[tail].jl,p.jl);
                arr[tail].jl[p.k]=i+'0';
                arr[tail].k=p.k+1;
                arr[tail].jl[arr[tail].k]=0;
                    tail++;
                }
            }
        }
    }
     printf("impossible\n");
}

int main()
{
    scanf("%d%d%d",&a,&b,&c);
    bfs();
}

cf

这场cf的第一题没什么难度，其实第二题也没什么难度，但是自己想岔了一个点，就一直出不来。

Problem - B - Codeforces

分析：

首先要明白它这个数组里面的数是可以随意变换位置的，也就是说你想让它放在哪里就放在哪里，所以我最开始的想法的就是以0的个数为界限，分为三大块。第一大块，全是0的情况，那结果就是1；第二大块，0比非0数的个数少的情况，那么那些非零数是可以插空的，所以结果为0；第三大块，也就是我昨天出问题的地方，我多想了一个3，我当时想着如果0比非零数的个数多，我就把所有的非零数往后堆，那就会出现“00000111”的情况，我觉得就是3，但是其实不是，如果把它插空“01010100”，那么它的结果应该是2，所以最后一大块的判断分两部分，第一部分，如果它的最大值就是1，那么结果是2；如果最大值比1大，那结果就是1，就像“00000311”，这里的原理就是只要我的最大比1大，那我就把这个最大值放在一堆数的最前面，后面的数两两相加，一定都会大于或等于2.

代码如下：

#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        int l1=0;//0的数量
        int max=-1;
        for(int i=0;i<n;i++)
        {
            int a;
            scanf("%d",&a);
            if(a==0)
            l1++;
            if(max<a)
            max=a;
        }
        if(l1==n)
        printf("1\n");
        else if(l1<=(n+1)/2)
        printf("0\n");
        else if(max==1)
        printf("2\n");
        else 
        printf("1\n");
    }
}

小郭同学1564
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用java写穿越火线代码_编写可测试的 JavaSript 代码
weixin_31520435的博客
02-26 529
无论我们使用和Node配合在一起的测试框架，例如Mocha或者Jasmine，还是在像PhantomJS这样的无头浏览器中运行依赖于DOM的测试，和以前相比，我们有更好的方式来对JavaScript进行单元测试。然而，这并不意味着我们要测试的代码就像我们的工具那样容易！组织和编写易于测试的代码需要花费一些精力和并对其进行规划，但是在函数式编程的启发下，我们发现了一些模式，当我们需要测试我们的代码时...
CF专用无盘系统，预防各种机器码.zip
02-02
为NEW原mo团队打造免费无盘系统，防止机器码最低一小时，最高24小时，不会出现30天，365天机器码现象，纯属为用户准备的福利无任何广告，病毒等问题，笔记本用户安装前看自己电脑是否适配！台式电脑直接用！这是预防...
Java面试题大全（每日更新）
每日一记，每周一结。
07-02 362
Collection是一个接口，定义了集合的通用行为，而Collections是一个工具类，提供了对集合的操作方法。我们可以使用Collections类的方法对实现了Collection接口的具体集合对象进行操作。每种集合容器都有其特定的用途和适用场景，选择合适的容器可以提高代码效率和可读性。​ LinkedHashSet：基于哈希表和链表实现的集合，保持元素的插入顺序。​ TreeSet：基于红黑树实现的有序集合，按照元素的自然顺序进行排序。
最新Java面试题整理（附答案）
Java笔记
02-10 4916
Java基础知识篇 面向对象和面向过程的区别 面向过程： 　　优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 缺点：没有面向对象易维护、易复用、易扩展 面向对象： 　　优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加...
一场CF的台前幕后
ezoixx130's Blog
08-15 4833
转自VFlea King的博客，原文地址：上 下   等你等了五千年，只为这一刹那的回眸一笑。   前奏 大约4月份的时候，业界毒瘤pyx噔噔噔跑过来说：“酷爱！我YY了一道题！准备当CF的C” 我当时就被吓傻了。"Yet another Chinese round?" “区间取模，区间求和” 感觉这题还不错？不过pyx嫌水了…… 好办！当时我刚刚出完动态仙人掌不久，于是一拍脑袋...
Java 并发在项目中的使用场景
weixin_43837268的博客
02-06 3182
此外，如果这时有另外一个进程也读文件，读文件的操作就会排队，磁盘驱动在完成一个进程的读操作后，发现有排队的任务，就会立即启动下一个读操作，这样 IO 的使用率也上来了。在一个时间片内，如果一个进程进行一个 IO 操作，例如读个文件，这个时候该进程可以把自己标记为“休眠状态”并出让 CPU 的使用权，待文件读进内存，操作系统会把这个休眠的进程唤醒，唤醒后的进程就有机会重新获得 CPU 的使用权了。操作系统做任务切换，可以发生在任何一条 CPU 指令执行完，是的，是 CPU 指令，而不是高级语言里的一条语句。
一场CF的台前幕后（上）
VFleaKing的博客
05-24 6406
（重发下这篇原发于 2014-06-03的网易博客） 等你等了五千年，只为这一刹那的回眸一笑。 前奏 大约4月份的时候，业界毒瘤pyx噔噔噔跑过来说：“酷爱！我YY了一道题！准备当CF的C” 我当时就被吓傻了。"Yet another Chinese round?" “区间取模，区间求和” 感觉这题还不错？不过pyx嫌水了…… 好办！当时我刚刚出完动态仙人掌不久，于是一拍...
637道Java面试题（含答案）
跑码场
03-01 1498
637道Java面试题（含答案），涵盖Java基础、Java并发、Spring、Spring Boot等多方面面试要点
Java最全八股文（2023最新整理）
热门推荐
Tyson0314的博客
02-16 5万+
Java面试八股文
Java的面试题
weixin_58276266的博客
08-16 300
Java基础知识篇 面向对象和面向过程的区别 面向过程： 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 缺点：没有面向对象易维护、易复用、易扩展 面向对象： 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护 缺点：性能比面向过程低 Java语言有哪些特点？ 　　1，简单易学；2，面向对象（封装，继承，多态）；3，平台无
基于Java实现的物品协同过滤(ItemCF)推荐系统源码
03-25
项目概述：基于Java开发的物品协同过滤(ItemCF)推荐系统，该系统包含了核心推荐算法以及相应的用户界面和数据库结构。项目主要采用Java语言编写，共计53个文件，其中包含14个Java源代码文件、12张图片文件（jpg格式...
CF_Java.zip_CF_Java_Java CF算法_协同过滤
09-23
协同过滤（Collaborative Filtering，简称CF）是一种广泛应用于推荐系统中的算法，它...这个Java实现的CF算法提供了一个基础框架，可以根据实际需求进行调整和优化。理解并掌握这种算法有助于构建更高效的推荐系统。
ZLG_CF.rar_ZLG_CF_zlg_读写CF卡
09-23
标题“ZLG_CF.rar_ZLG_CF_zlg_读写CF卡”表明这是一个针对ZLG开发板的CF卡读写代码资源，而“描述”中提到的“带有文件系统”则意味着该代码集不仅包含低级的I/O操作，还可能涉及更高级别的文件管理和操作。...
C_Read_CF.zip_CF 读写_CF卡_CF卡 读写
09-24
在IT领域，尤其是在嵌入式系统和数据存储技术中，CF（CompactFlash）卡是一种常见的非易失性存储设备。本文将围绕标题“C_Read_CF.zip_CF 读写_CF卡_CF卡 读写”和其描述展开，详细介绍如何使用C语言进行CF卡的读写...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1152
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 415
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 453
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 796
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
用java语言写一个UserCF
05-10
好的，以下是Java语言实现的UserCF推荐算法示例代码： ```java import java.util.*; public class UserCF { // 用户数 private int userCount; // 物品数 private int itemCount; // 用户物品评分表 private...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值