赞
踩
目录
始定两个字符集合, 一个为全量字符集, 一个为已占用字符集。
已占用的字符集合中的字符不能再使用,要求输出剩余可用字符集。
输入描述:
输入为一个字行串,字符串中包括了全量字符集和已占用字符集。两个字符集使用@连接。@前的字符集为全量字符集,@后的字符集合为已占用字符集。
已占用字符集中的字符一定是全量字符集中的字符。字符集中的字符跟字符之间使用英文逗号分隔。
字符集中的字符表示为字符加数字,字符跟数字使用英文冒号分隔,比如a:1,表示1个a字符。字符只考虑英文字母,区分大小写,数字只考虑正整形,数量不超过 100,如果一个字符都没被占用,@标识仍然存在,例如a:3,b:5,c:2@
输出描述:
可用字符集。输出带回车换行
示例输入:
a:3,b:5,c:2@a:1,b:2
示例输出:
a:2,b:3,c:2
题解:
- import java.util.HashMap;
- import java.util.LinkedHashMap;
- import java.util.Map.Entry;
- import java.util.Scanner;
-
- public class main {
- public static void main(String args[]){
- Scanner scan=new Scanner(System.in);
- String str=scan.nextLine();
- String[] tmp=str.split("@");
- if(tmp.length<2){
- System.out.println(tmp[0]);
- return;//作者:无人机大佬朱志斌
- }
- String[] arryOne=tmp[0].split(",");
- String[] arryTwo=tmp[1].split(",");
- HashMap<String,Integer> map=new LinkedHashMap();
-
- for(int i=0;i<arryOne.length;i++){
- String[] tmpOne=arryOne[i].split(":");
- int cnt=Integer.valueOf(tmpOne[1]);
- map.put(tmpOne[0],cnt);
- }
-
- for(int i=0;i<arryTwo.length;i++){
- String[] tmpTwo=arryTwo[i].split(":");
- int cnt=Integer.valueOf(tmpTwo[1]);
- map.put(tmpTwo[0],map.get(tmpTwo[0])-cnt);
- }
-
- String result="";
-
- for(Entry<String,Integer> entry:map.entrySet()){
- if(entry.getValue()>0){
- result=result+entry.getKey();
- result=result+":";
- result=result+entry.getValue();
- result=result+",";}
- }
- char[] tmpThree=result.toCharArray();
- String res="";
- for(int i=0;i<tmpThree.length-1;i++){
- res+=tmpThree[i];
- }
- System.out.println(res.toString());
- }
- }

输入描述:
1.测试用例中间无空格,无需考虑空格。
2.测试用例表达式中只会出现如下字符: "0","1","(",")","&","|","!"。3.测试用例所给的输入都是合法输入,无需要考底非法输入。
4.测试用例表达式长度不会超过 128 个字符。
5.括号可以重复嵌套。
例如:
1|(1&0) 返回值:1
1&0|0&1 返回值:0
!0&1|0 返回值:1
((!0&1))|0 返回值:1
输出描述:
输出逻辑运算后的最终结果:0 或者1
在一个int型整数(对应的比特流)中查找某个比特块(本题固定为5,即二进制“101”)出现的次数及首次出现位置,说明:
1.输入次数和首次出现的位置中间用空格隔开。
2.位置从0 开始,即最右边位置为 0,向左依次增加。
3.如果该int型整数中没有找到该比特块,次数返回0,位置返回-1。
4.比特位允许重复使用,如 10101 中间的比特1 可以与前面的01 组成 101,也可以与后面的 10 组成 101。
输入描述:
一个任意的十进制 int 型整数
输出描述:
在输入整数对应的二进制比特流中,比特块(101)出现的次数和首次出现的位置,次数和位置分别以十进制 int 型整数表示,中间用空格隔开
示例输入:
21
示例输出:
2 0
代码1(不确定是否AC,如有问题,求大神斧正)
- import java.util.Scanner;
-
- public class Main{
- public static void main(String[] args) {
- Scanner in = new Scanner(System.in);
- while(in.hasNext()){
- int cur = in.nextInt();
-
- //将整数转化为二进制数
- String binStr = Integer.toBinaryString(cur);//作者:海思安全总工程师程昱婷博士
-
- //求字符串中的子串
- int count=0;
- int firstIndex=-1;
-
- //方法1:从前往后(当101首次出现,flag置false,则不记录以后出现的位置)
- // boolean flag = false;
- // for(int i = 0; i <binStr.length()-2; i++){
- // if(binStr.substring(i,i+3).equals("101")){
- // count++;
- // if(!flag){
- // firstIndex=i;
- // }
- // flag = true;
- // }
- // }
-
- //方法2:从后往前(不断更新首次出现的位置)
- for(int i = binStr.length(); i > 2; i--){
- if(binStr.substring(i-3,i).equals("101")){
- count++;
- firstIndex=i-3;
- }
- }
- System.out.println(count+" "+firstIndex);
- }
- }
- }

代码2(AC)
- import java.util.Scanner;
-
- public class bitsBlock {
- public static void main(String[] args) {
- Scanner in = new Scanner(System.in);
- while(in.hasNext()){
- int cur = in.nextInt();
- //将整数转化为二进制数
- String binStr = Integer.toBinaryString(cur);
-
- //求字符串中的子串
- int[] res = getNum(binStr);
- System.out.println(res[0]+" "+res[1]);
- }
- }
-
- public static int[] getNum(String str){
- char arr[] = str.toCharArray();
- int[] res = new int[2];
- res[1]=-1;
- boolean flag = false;
- for(int i = arr.length-1; i >=2; i--){
- if(arr[i]=='1'){
- if(arr[i-1]=='0'&&arr[i-2]=='1'){
- res[0]++;
- if(!flag){
- res[1]=(arr.length-1)-i;
- }
- flag = true;
- }
- }
- }
- return res;
- }
- }

某程序员小A,有一种表格数据需要存储在文件中。表格中的每行,由若干个字骤组成,每个字段可以是整数字符串(字符包数字字母以及特殊字符!@#¥%……&*()",)。小A 设计了一种存储格式,采用文本的方式对表格数据进行存储。文本文件中的每行,代表了表格数据中的行数据。具体格式如下:
1、采用号分隔不同的字段(逗号前后无空格);
2、数字直接采用 10 进制的文本存储;
3、字符串的存储规则如下:
1)如果字符串中包含逗号以及双引号,则字符串必须在头尾各增加一个双引号,且中间的双引号需要用连续两个双引号来表示。例如:"a,""b",表示字符串 a,"b
2)如果字符串中末包含逗号以及双引号,则字符串不强制要求在头尾增加双引号,可直接存储。例如:abc,或者"abc"都可以。
4、空字符串不存储任何字符,例如:a,,b中,有3 个字段,分别为a,空字符串,b;
请帮助小A 设计个算法,用来将单行文本,解析成多个字段,并输出。
输入描述:
用于存储单行表格数据的一行文本。
1、用手分隔不同字段的号前后一定没有空格,程序设计者无需考虑此种异常情况
2、除数字、字母以及特殊字符!@#¥%……&*()",外,不会出现其它字符
3、输入的数字一定是 10 进制合法正整数,不会出现负数、小数、其它进制数以及格式错误的 10 进制数
输出描述:
第一行,字符串格式是否正确,正确输出字段个数,不正确输出ERROR。
如果输入字符串格式不正确,则输出结束。如果字符串格式正确,则输出每个字段的值,每个字段单独占一行。
数字采用 10 进制输出,字符串输出解析后的值。空字符串输出--
示例输入:
a,,1,"b,"""
示例输出:
4
a
--
1
b,"
思路
如果首次遇到双引号,则将将flag置为真,之后除双引号之外的所有字符,包括逗号,全部保留;
如果再次遇到双引号,则将将flag置为假,恢复正常操作。
题解:(没有AC,只过了80%)
- import java.util.Scanner;
- import java.util.List;
- import java.util.ArrayList;
- public class Main{
- public static void main(String[] args){
- Scanner sc=new Scanner(System.in);
- String s=sc.nextLine();
- List<String> list=new ArrayList<>();
- StringBuilder sb=new StringBuilder();
- if(s!=null){
- boolean flag=false;//作者:外星小小朋友
- for(int i=0;i<s.length();i++){
- char c=s.charAt(i);
- if(c==','){
- if(flag){
- sb.append(',');
- }else{
- if(sb.length()==0){
- list.add("--");
- }else{
- list.add(sb.toString());
- }
- sb=new StringBuilder();
- }
- }else if(c=='"'){
- if(i+1<s.length() && s.charAt(i+1)=='"'){
- sb.append('"');
- i++;
- }else if(flag){
- list.add(sb.toString());
- sb=new StringBuilder();
- flag=false;
- }else{
- flag=true;
- }
- }else{
- sb.append(c);
- }
- }
- if(sb.length()!=0){
- list.add(sb.toString());
- }
- if(flag){//作者:猴哥
- System.out.println("ERROR");//作者:西瓜味的猫
- }else{
- System.out.println(list.size());
- for(String str:list){
- System.out.println(str);
- }
- }
- }
- }
- }

有一款社交软件 APP,假说注朋用户m人(0<m<50),用编号为 0~m-1,r[i,j]表示用i 和用户j 好友关系(r[i][j]=0 代表i和j不是好友,r[i][j]=1~9 代表是好友目数值代表熟悉程度,数值越大代表越熟悉,其中r[i][j]=r[j][i],0<=i,j<=m-1)试编制程序,输出某个特定用户i的n 度好
友(1 度好友代表直接好友,2 度好友代表好友的好友,以此类推1<=n<=10),并按推荐值降序输出好友列表(推荐值相同的好友,按好友编号升序,其中推荐值是指关系熟活度之和,比如朋户i和j是好友,且熟悉度r[i][j]=4 ,j和k是好友且熟活度小r[j][k]=6,且i和k 不是好友即r[i][k]=0,则用户k 是用户i的2 度好友且推荐值为可r[i][j]+r[j][k]=10),如果此用户i 没有n 度好友输出-1。
输入描述:
输入一个整数T,表示有T组测试数据(0<T<100)。
对于每组测试数据输入2行,
第1行 输入3 个整型数 m,i,n 分别代表用户数 m,某个用户编号 i,n度好友, 即代表本组测试需要输出用户i的n度好友
第2 行 输入1 个整型数 k,接下来 3*k 个整数用空格隔开,每三个组成关系对,每个关系由3 个整型数组成 i,j,w 代表用户主和的熟悉程度,即 r[i][j]=w,没有输入的关系默认为非好友(r[i][j]=r[j][i]=0)
输出描述:
输出T行,每行对应每组测试数据的用户i的n 度好友,按推荐值降序输出,推荐值相同的好友按好友编号升序,编号间用空格隔开。如果没有n 度好友输出-1
示例输入:
2
10 5 2
13 0 3 5 0 4 9 0 6 8 0 7 5 1 2 6 1 6 1 2 9 7 3 4
3 3 5 3 3 8 3 3 9 3 5 8 9 7 8 9
10 0 2
13 0 3 5 0 4 9 0 6 8 0 7 5 1 2 6 1 6 1 2 9 7 3 4
3 3 5 3 3 8 3 3 9 3 5 8 9 7 8 9
示例输出:
7 0 4 9
1 5 8 9
代码:暂无
将长N*M 厘米的矩形区域划分成N行M 列(每行每列的宽度均为1 厘米),在第i行第j列的位置上叠放Ai,j个边长为1 厘米的正方体(1≤Ai,j≤100),所有正方体就组成了一个立体图形,每个正方体六个面中的一部分会被其它正方体遮挡,未被遮挡的部分的总面积即为该立体图形的表面积,那么该立体图形的表面积是多少平方厘米?
输入描述:
第一行包含两个整数N和M,1≤N,M≤1000。
接下来N行,每行包含M个整数,第i行的第j个整数表示 Ai,j
输出描述:
输出表面积的大小。
示例输入:
2 2
2 1
1 1
示例输出
20
题解:
- import java.util.Scanner;
- public class Main{
- public static void main(String[] args){
- Scanner sc=new Scanner(System.in);
- int n=sc.nextInt();
- int m=sc.nextInt();
- int[][] grid=new int[n][m];
-
- for(int i=0;i<grid.length;i++){
- for(int j=0;j<grid[0].length;j++){
- grid[i][j]=sc.nextInt();
- }
- }
- int res=surfaceArea(grid);
- System.out.println(res);
- }
- public static int surfaceArea(int[][] grid){
- int surface1 = 0; //记录每个位置上组合立方体的表面积
- int surface2 = 0; //记录每个位置上组合立方体的邻接面积
- for (int i = 0; i < grid.length; i++) {
- for (int j = 0; j < grid[0].length; j++) {
- if (grid[i][j] != 0) {
- surface1 += grid[i][j] * 4 + 2; //记录当前位置上组合立方体的表面积
- }
- if (i != grid.length - 1) {
- //记录 i 行与 i + 1 行的邻接面积
- surface2+=(grid[i][j]>grid[i+1][j]?grid[i+1][j]:grid[i][j])*2;
- }
- if (j != grid[0].length - 1) {//作者:孙作者
- //记录 j 列与 j + 1 列的邻接面积
- surface2+=(grid[i][j]>grid[i][j+1]?grid[i][j+1]:grid[i][j])*2;
- }
- }
- }
- return surface1 - surface2;
- }
- }

英语老师看你老是在英语课上和周围同学交头接耳,所以给你布置了一份额外的家庭作业来惩罚惩罚你:你有一个字符串 s,请你在s 的所有子串中,找到出现次数最多的子串,告诉老师它的出现次数。
输入
共一行,一个字符串 s,仅由英文小写字母组成,1<|s|<10000。
输出
一个正整数,表示最大出现次数。
样例输入
aba
样例输出
2
思路1:求出全部子串,然后统计,但是这样会内存超限;
思路2:只统计长度为1的子串即可,即判断字符串中每个char出现的次数。因为长度大于1的子串出现的次数必然小于长度大于1的子串出现的次数,故省略不计。
饭后散步是个很好的习惯,一天晚上,小A 在条笔直的路上散步,起点在路上某处,但是因为路上没有标识,他并不知道这个起点位于路上的哪个位置,现在将道路划分为 N-1 个等距的部分,你可以把这条路当成一个数轴,道路上的结点标记为 1~N,起点只可能是这N 个点中的一个。
但是小A 还提供了一个重要信息,他每隔一段时间就会用手机看一下自己走了多远,记作D,但是他并不记得他是朝着哪个方向走的,唯一可以确定的是,在两次看手机的间隔中他不会改变方向,每次看完手机后他可能继续向前或者回头走。
那么问题来了,已知他在散步过程中始终在 1~N 的范围内,那么符合上述条件的终点可能有多少个呢?
输入
输入第一行包含一个正整数 N,M,N 表示道路的长度,也是数轴上点的数量,M 是小A提供的D 的数量。(N,M<=20000)
接下来有M行,每行一个正整数D,表示小A 朝着某个方向走了D 个单位。(D<=20000)
输出
输出仅包含一个整数,表示可能的起点的数量。
输入样例
10 3
5
2
6
输出样例
8
代码
- import java.util.Scanner;
-
- public class Main{
- public static void main(String[] args) {
-
- Scanner sc=new Scanner(System.in);
- int n=sc.nextInt();
- int m=sc.nextInt();
- int[] loc=new int[m];
- int count=0;
- for (int i = 0; i < m; i++) {
- loc[i]=sc.nextInt();
- }
- for(int j=1;j<=n;j++){
- if(panduan(j,n,loc)){
- count++;
- }
- }
- System.out.println(count);
- }
- public static boolean panduan(int i,int n,int[] loc){
- boolean result=false;
- for(int j=0;j<loc.length;j++){
- if(i+loc[j]<=n){
- i+=loc[j];
- result=true;
- continue;
- }else if(i-loc[j]>=1){
- i-=loc[j];
- result=true;
- continue;
- }else{
- result=false;
- return result;
- }
- }
- return result;
- }
- }

参考力扣768
某校在积极推行无人监考制度,但是总有学生是不自觉的,如果将两个很熟的异性朋友放在同一个考场里,他们就会交流甚至作弊。因此一个考场中不能允许两个很熟的异性朋友存在,学校希望通过搬出一部分学生的方法来改善这一问题。但是又因为教率数量有限,因此希望个教率中容下的学生尽可能多,即需要搬出教室的学生数量尽可能少,请你输出搬出教室人数最少,且字典序最小的方案。
输入描述
输入第行有两个整数n和 m,分别表示有n 个男生和n 个女生,有m 个朋友关系。
(1<=n<=500,1<=m<=100000
接下来m行,每行有两个整数,x和 y,表示第号男生和第y 号女生是朋友。男生的编号均为[1,n],女生的编号为[n+1,2n]
输出描述
输出第一行包含一个整数 a,表示最少需要搬出教室的人数。
输出第二行有a 个整数,即a 个需要搬出教室的人的编号,要求人数最少,且字典序最小
样例输入
2 2
3 1
1 4
样例输出
1
3
代码
- import java.util.HashMap;
- import java.util.Scanner;
-
- public class testOne {
- public static void main(String args[]){
- Scanner scan=new Scanner(System.in);
- int n=scan.nextInt();
- int m=scan.nextInt();
- n=n*2;
- HashMap<Integer,Integer> count=new HashMap<>();
- int[][] relation=new int[n+1][n+1];
- for(int i=1;i<=n;i++)
- for(int j=1;j<=n;j++)
- relation[i][j]=0;
- for(int i=0;i<m;i++){
- int tmp1=scan.nextInt();
- int tmp2=scan.nextInt();
- if(count.get(tmp1)!=null){
- count.put(tmp1, count.get(tmp1)+1);
- relation[tmp1][tmp2]=1;
- relation[tmp2][tmp1]=1;
- }
- else{
- count.put(tmp1, 1);
- relation[tmp1][tmp2]=1;
- relation[tmp2][tmp1]=1;
- }
- }
-
- int[] array=new int[10000];
- int loc=0;
- int k=-1;
- String s="";
- while(panduan(relation,n+1)){
- loc=location(count,n+1);
- count.put(loc,0);
- array[++k]=loc;
- for(int i=1;i<n+1;i++)
- for(int j=1;j<n+1;j++)
- if(i==loc||j==loc)
- relation[i][j]=0;
-
- }
- int num=0;
- for(int i=0;i<array.length;i++)
- if(array[i]>0)
- num++;
- System.out.println(num);
- for(int i=0;i<num-1;i++)
- System.out.print(array[i]+" ");
- System.out.println(array[num-1]);
-
- }
- public static int location(HashMap<Integer,Integer> count,int n){
- int max=0;
- int maxIndex=0;
- for(int i=0;i<=n;i++){
- if(count.get(i)!=null && count.get(i)>max){
- max=count.get(i);
- maxIndex=i;
- }
- }
- return maxIndex;
- }
- public static boolean panduan(int[][] relation,int n){
- for(int i=1;i<n;i++)
- for(int j=1;j<=i;j++)
- if(relation[i][j]==1)
- return true;
- return false;
- }
- }

给N名员工的工资清单,按照工资分布的人数降序排序,如果有两个工资的人的数目一致(大概意思就是假设3000工资有3个人,5000也是三个人),就按照工资在给定清单的顺序里面排序。
输入
20(人数)
4 1 4 4 2 1 2 3 1 9 1 2 8 7 5 6 3 4 3 6
输出
4 4 4 4 1 1 1 1 2 2 2 3 3 3 6 6 9 8 7 5
代码
- /*
- 1.用Map来统计工资及其出现的频次,由于需要对频次相同的工资按照原来的顺序打印,所以需要使用到是LinkedHashMap,Key为工资,Value为出现频次;
- 2.用Map的EntrySet构造List, 并对list按照工资出现频次排序;
- 3.将上述List从头到尾添加至结果集List中,频次为n,则重复添加n次。
- */
- public class Main{
- public static void main(String[] args){
- Scanner sc=new Scanner(System.in);
- int num=sc.nextInt();
- int[] nums=new int[num];
- for(int i=0;i<num;i++){
- nums[i]=sc.nextInt();
- }
- List<Integer> salaryList=sortSalary(nums);
- for(int i:salaryList){
- System.out.print(i+" ");
- }
- }
- public static List<Integer> sortSalary(int[] nums){
-
- //一维数组salaryList用于存放排序后的工资列表。
- List<Integer> salaryList = new ArrayList();
- //freMap用于统计工资出现的凭此,key为工资,value为出现频次
- Map<Integer,Integer> freMap = new LinkedHashMap<Integer, Integer>();
- //二维数组tempList用于存放带频次信息的工资列表,tempList[i][0]存放工资,tempList[i][1]存放频次
- List<Map.Entry<Integer,Integer>> tempList = null;
-
- //统计频次
- for(int i=0;i<nums.length;i++){
-
- if(freMap.containsKey(nums[i])){
- freMap.put(nums[i],freMap.get(nums[i])+1);
- }else {
- freMap.put(nums[i],1);
- }
- }
-
- tempList = new ArrayList(freMap.entrySet());
-
- Collections.sort(tempList, new Comparator<Map.Entry<Integer, Integer>>() {
- public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
- return o2.getValue()-o1.getValue();
- }
- });
-
- for(Map.Entry<Integer,Integer> entry : tempList){
- for(int i=0;i<entry.getValue();i++){
- salaryList.add(entry.getKey());
- }
- }
- return salaryList;
- }
- }

参考:https://blog.csdn.net/weixin_44003141/article/details/98882568
https://blog.csdn.net/hongtao_6/article/details/97246319
给定两个版本号,只有在版本号更高的时候,才可以升级。
输入
2
6.6.6 6.6.7
1 1.0
输出
true
false
代码
- import java.util.Scanner;
-
- public class Main {
-
- public static void main(String[] args) {
- Scanner sc = new Scanner(System.in);
- int caseNum = Integer.valueOf(sc.nextLine());//sc每接收一种类型的数据就要new一个新的Scanner类
- boolean[] canUpgradeArr=new boolean[caseNum];
-
- for(int i=0;i<caseNum;i++) {
- String line = sc.nextLine();
- String[] versionArr = line.split(" ");
- canUpgradeArr[i]=canUpgrade(versionArr[0],versionArr[1]);
- }
- for (boolean b : canUpgradeArr) {
- System.out.println(b);
- }
- }
- public static boolean canUpgrade(String oldVersion,String newVersion) {
- String[] oldVersionArr = oldVersion.split("\\.");
- String[] newVersionArr =newVersion.split("\\.");
- int maxLen = Math.max(oldVersionArr.length, newVersionArr.length);
- for(int i=0;i<maxLen;i++) {
- int curOld = i<oldVersionArr.length?Integer.valueOf(oldVersionArr[i]):0;
- int curNew = i<newVersionArr.length?Integer.valueOf(newVersionArr[i]):0;
- if(curOld!=curNew) {
- return true;
- }
- }
- return false;
- }
- }

参考力扣202
抖音上每天都有几亿用户,如果用户A和B 互动不少于3次,我们就认为A和B 属于“豆油”,如果A和B “豆油”,B和C 的是“豆油”,那么A和C 也互为“豆油”,我们定义“豆油瓶”就是由直系和间接朋友组成的群体。
给定1个N*N 的矩阵M,代表抖音上所有用户的互动次数,如果M[i][j]=5,那么第i个和第j个用户就互动过5次,为0 的话代表没有互动其中,对i=j,即同一个用户,互动次数我们计为0.请你计算并输出发现的抖音上所有“豆油瓶”的个数。
输入
示例1:
3
0 4 0
4 0 0
0 0 0示例2:
3
0 4 0
4 0 6
0 6 0
输出
示例1:
2
示例2:
1
代码
- import java.util.Scanner;
-
- public class Main {
-
- //求无向连通子图个数
- public static void main(String[] args) {
- Scanner sc=new Scanner(System.in);
- int userNum=sc.nextInt();
-
- int[][] grid=new int[userNum][userNum];
- for(int i=0;i<userNum;i++){
- for(int j=0;j<userNum;j++){
- if(sc.nextInt()>=3){
- grid[i][j]=1;
- }
- }
- }
-
- //已经遍历过的用户
- boolean[] visited=new boolean[grid.length];
-
- int res=0;
-
- for(int i=0;i<grid.length;i++){
- if(!visited[i]){
- res++;
- dfs(i,grid,visited);
- }
- }
- System.out.println(res);
- }
-
- public static void dfs(int i,int[][] grid,boolean[] visited){
- visited[i]=true;
- for(int j=0;j<grid.length;j++){
- if(!visited[j] && grid[i][j]==1){
- dfs(j,grid,visited);
- }
- }
- }
- }

圆形花园共有n个入口,现在要修路,穿过花园,要求每个路口只能有一条路,所有路均不会相交,求所有可行的方法总数。
思路:
卡特兰数
代码
- import java.io.*;
- import java.util.*;
- import java.util.Map.Entry;
- import java.text.*;
- import java.math.*;
- import java.util.regex.*;
-
- public class Main1 {
-
- private static HashSet<Integer> set = null;
- /** 请完成下面这个函数,实现题目要求的功能 **/
- /** 当然,你也可以不按照这个模板来作答,完全按照自己的想法来 ^-^ **/
- static String getIndexAndLongest(String users,int k) {
- if(users==null) {
- return "0 0";
- }
- set = new HashSet<>();
- for(int i=0;i<users.length();i++) {
- if(users.charAt(i)=='b') {
- set.add(i);
- }
- }
- String idx = getIndex(users);
- String longest = getLongest(users, k);
- return idx+" "+longest;
- }
- private static String getLongest(String users,final int k) {
- int size = users.length();
- int maxBoy = 0;
- for(int i=0;i<size;i++) {
- int start = (i+1)%size;
- int count = 0;
- int boy = users.charAt(i)=='b'?1:0;
- while(count<=k&&start!=i) {
- if(users.charAt(start)=='g') {
- count++;
- } else {
- boy++;
- }
- start = (start+1)%size;
- maxBoy = Math.max(boy, maxBoy);
- }
- }
- return maxBoy+"";
- }
- private static String getIndex(String users) {
- int size = users.length();
- int maxGril = 0;
- int minIdx = Integer.MAX_VALUE;
- Iterator<Integer> iterator = set.iterator();
- while(iterator.hasNext()) {
- Integer entry = iterator.next();
- int idx = entry;
- int left = (idx+size-1)%size;
- int right = (idx+1)%size;
- int leftCount = 0;
- int rightCount =0;
- while(users.charAt(left)=='g'&&left!=right) {
- left = (left-1+size)%size;
- leftCount++;
- }
- while(users.charAt(right)=='g'&&right!=left) {
- right = (right+1)%size;
- rightCount++;
- }
- int count = leftCount+rightCount;
- if(maxGril<count) {
- minIdx = entry;
- maxGril = count;
- } else if(maxGril==count&&minIdx>entry) {
- minIdx = entry;
- }
- }
-
- return minIdx+"";
- }
-
- public static void main(String[] args) {
- Scanner in = new Scanner(System.in);
- String res;
- String _users;
- int k = 0;
- try {
- _users = in.nextLine();
- String str = in.nextLine();
- k = Integer.valueOf(str);
- } catch (Exception e) {
- _users = null;
- }
- res = getIndexAndLongest(_users,k);
- System.out.println(res);
- }
- }

产品经理小梅喜欢和他的男朋友小白一块玩扑克游戏。每一局,小梅抽取N 张扑克牌,自左向右依次排列在桌面上;小白也抽取 M(8>=N>=M=1)张扑克牌,自左向右依次排列在桌面上。
小梅需要进行N 个回合,使用手中的扑克牌,组成一个新的扑克牌的序列。每个回合,小梅有d、l、r三种策略:
----选择d时,小梅将最左边的扑克牌丢弃
----选择l时,小梅将最左边的扑克牌取出,放到新的扑克牌序列的最左边
----选择r时,小梅将最左边的扑克牌取出,放到新的扑克牌序列的最右边
N 个回合完成,新的扑克牌序列与小白的扑克牌完全一样(只考虑数字,不考虑花色),则小梅胜出
小梅向程序员小岛提了一个需求,希望了解获胜的全部方法。简化起见,扑克牌仅包含 1-9。
输入描述
首先,输入数字s,作为局数(1<=s<=10)
每一局,分别输入两行字行串,另代表小梅的抽取的扑克牌 (从左问右排列)和小白抽职到的扑克(从左向右排列)
输出描述
对于每一局,在开始和结束,分别输出 { 和 }
输出获胜的方法,回合策的结尾出一个空格。若存在多个获胜万法,请按宇典序的升序输出。
代码
10.VIVO
1.跳跃游戏||:参考力扣
2.约瑟夫环
3.背包问题变种:将数组分成两部分使得两部分的和的差最小
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。