2020刷题日记

最新推荐文章于 2021-11-27 18:29:20 发布
最新推荐文章于 2021-11-27 18:29:20 发布
阅读量434 收藏 2
点赞数
分类专栏： 人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cobracanary/article/details/104032522
版权

因为要准备保研，所以想刷刷百练上面的题目，同时因为百练上面题目做的人比较少，大多数哦人又是使用c++做的，所以想在网上找到Java的百练答案又比较难，这篇博客即是我的刷题日记，也当作一个Java百练题解吧，想要搜索直接在本博客ctrl+f然后输入题号搜索即可

2020.1.18
我果然还是不甘心当一个five啊，今天开始刷百练的题目

有一说一之前刷过很多leetcode，做百练还是不难，但是百练不像leetcode，不能查看代码执行错误的用例，不能自定义测试用例，这点就很难受。

总结一下Java输入Scanner的几个常用API:

  • nextInt()：跳过特殊字符获取下一个整数，但是获取之后cursor会停留在本行，不会跳到下一行
  • next()：获取下一个字符串，会自动跳过空格，换行符等特殊字符，cursor可以移动到下一行
  • nextLine():从当前的cursor开始读到换行符，会将cursor放在下一行，如果没有换行符不可以获取字符串。
    在这里插入图片描述
    执行结果：
    在这里插入图片描述
    这是因为当读取12的时候，cursor到了12的后面换行符的前面，并没有跳到下一行，二nextLine()从当前cursor读取直到遇到换行符，所以读取了空

1001:Exponentiation

import java.math.BigDecimal;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        while(cin.hasNext()){
            BigDecimal R =  cin.nextBigDecimal();
            int n = cin.nextInt();
            BigDecimal ans = R.pow(n);
            //去掉末尾多余的0
            ans = ans.stripTrailingZeros();
            //不使用科学计数法
            String plain = ans.toPlainString();
            if (plain.startsWith("0.")){
                plain = plain.substring(1);
            }
            System.out.println(plain);
        }
    }
}

2020.1.19

1088:滑雪

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int m = cin.nextInt();
        int n = cin.nextInt();
        int[][] hights = new int[m][n];
        for (int i = 0;i < m;i++){
            for (int j = 0;j < n;j++){
                hights[i][j] = cin.nextInt();
            }
        }

        System.out.println(maxLength(hights,m,n));
    }

    static int maxLength(int[][] hights,int m,int n){
        int[][] lengths = new int[m][n];
        int max = 0;
        for (int i = 0;i < m;i++){
            for (int j = 0;j < n;j++){
                if (lengths[i][j] == 0){
                    lengths[i][j] = length(hights,lengths,i,j,m,n);
                    max = Math.max(max,lengths[i][j]);
                }
            }
        }
        return max;
    }

    static int length(int[][] hights,int[][] lengths,int i,int j,int m,int n){
        int length = 1;
        if (i > 0 && hights[i][j] > hights[i - 1][j]){
            if (lengths[i - 1][j] == 0){
                lengths[i - 1][j] = length(hights,lengths,i - 1,j,m,n);
            }
            length = Math.max(length,lengths[i - 1][j] + 1);
        }

        if (i < m - 1 && hights[i][j] > hights[i + 1][j]){
            if (lengths[i + 1][j] == 0){
                lengths[i + 1][j] = length(hights,lengths,i + 1,j,m,n);
            }
            length = Math.max(length,lengths[i + 1][j] + 1);
        }

        if (j > 0 && hights[i][j] > hights[i][j - 1]){
            if (lengths[i][j - 1] == 0){
                lengths[i][j - 1] = length(hights, lengths, i, j - 1, m, n);
            }
            length = Math.max(length,lengths[i][j - 1] + 1);
        }

        if (j < n - 1 && hights[i][j] > hights[i][j + 1]){
            if (lengths[i][j + 1] == 0){
                lengths[i][j + 1] = length(hights, lengths, i, j + 1, m, n);
            }
            length = Math.max(length,lengths[i][j + 1] + 1);
        }

        lengths[i][j] = length;
        return length;
    }


}

1007:DNA排序

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int m = cin.nextInt();
        cin.nextLine();
        List<String> DNAs = new LinkedList<>();
        for (int i = 0;i < m;i++){
            DNAs.add(cin.nextLine());
        }

        Collections.sort(DNAs, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return nums(o1) - nums(o2);
            }
        });

        for (String DNA:DNAs){
            System.out.println(DNA);
        }
    }

    static int nums(String DNA){
        char[] chars = DNA.toCharArray();
        int numa = 0;
        int numc = 0;
        int numg = 0;
        int numt = 0;
        int len = DNA.length();
        for (char ch:chars){
            if (ch == 'A'){
                numa++;
            } else if (ch == 'C'){
                numc++;
            } else if (ch == 'G'){
                numg++;
            } else {
                numt++;
            }
        }

        int sum = 0;
        for(char ch:chars){
            if (ch == 'A'){
                numa--;
            } else if (ch == 'C'){
                numc--;
                sum += numa;
            } else if (ch == 'G'){
                numg--;
                sum += numa + numc;
            } else {
                numt--;
                sum += numa + numc + numg;
            }
        }

        return sum;
    }
}

4151:电影节

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        while (n != 0){
            Movie[] movies = new Movie[n];
            for (int i = 0;i < n;i++){
                int start = cin.nextInt();
                int end = cin.nextInt();
                Movie movie = new Movie(start,end);
                movies[i] = movie;
            }

            int index = 0;
            int count = 0;
            while (true){
                int minend = 2000;
                for (Movie movie:movies){
                    if (movie.getStartTime() >= index){
                        minend = Math.min(minend,movie.getEndTime());
                    }
                }
                if (minend == 2000){
                    break;
                } else {
                    count++;
                    index = minend;
                }
            }
            System.out.println(count);
            n = cin.nextInt();
        }
    }

    static class Movie{
        int startTime;
        int endTime;

        public Movie(int startTime, int endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
        }

        public int getStartTime() {
            return startTime;
        }

        public int getEndTime() {
            return endTime;
        }
    }
}

写一个保留位一小数的程序：

String ans=String.format("%.1f",c*d);

返回的是个字符串，结果是c*d保留一位小数的结果

2020.1.20
这个百练真是把👴气笑了，有时候代码就是死活提交不上去，我又想念leetcode了。

4094:秘密会谈

import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int s = cin.nextInt();
        int max = 0;
        for (int i = 0;i < n;i++){
            int start = cin.nextInt();
            int speed = cin.nextInt();
            int time = start + s / speed;
            max = Math.max(max,time);
        }
        System.out.println(max);
    }
}

4095:打字员

import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        for (int i = 0;i < n;i++){
            System.out.println(nums(cin.next()));
        }
    }

    //status 0:小写
    //1：大写
    static int nums(String str){
        int count = 0;
        int status = 0;
        char[] chars = str.toCharArray();
        for (char ch:chars){
            if ((ch >= 'a' && ch <= 'z' && status == 0) || (ch >= 'A' && ch <= 'Z' && status == 1)){
                count++;
            }else if (status == 0){
                status = 1;
                count += 2;
            } else {
                status = 0;
                count += 2;
            }
        }
        return count;
    }
}

4096:信号转换

import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        String str = cin.next();
        char[] chars = str.toCharArray();
        StringBuilder ans = new StringBuilder("");
        for (char ch : chars){
            if (ch == 'A'){
                ans.append(1);
            } else if (ch == 'B'){
                ans.append(2);
            } else if (ch == 'C'){
                ans.append('$');
            } else {
                ans.append("\n");
            }
        }
        System.out.println(ans.toString());
    }
}

4097:报站

import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        String[] stations = new String[n];
        for(int i = 0;i < n;i++){
            stations[i] = cin.next();
        }

        int m = cin.nextInt();
        for (int i = 0;i < m;i++){
            String start = cin.next();
            String end = cin.next();
            int startIndex = -1;
            int endIndex = -1;
            int j = 0;
            while(startIndex == -1 || endIndex == -1){
                if (stations[j].equals(start)){
                    startIndex = j;
                }
                if (stations[j].equals(end)){
                    endIndex = j;
                }
                j++;
            }
            if (startIndex <= endIndex){
                int k = startIndex;
                while (k != endIndex){
                    System.out.print(stations[k]+" ");
                    k++;
                }
                System.out.println(stations[endIndex]);
            } else {
                int k = startIndex;
                while (k != endIndex){
                    System.out.print(stations[k]+" ");
                    k--;
                }
                System.out.println(stations[endIndex]);
            }
        }
    }
}

4098:第二大价值

import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int m = cin.nextInt();
        for (int i = 0;i < m;i++){
            int n = cin.nextInt();
            Fruit max = new Fruit(0,0,0);
            Fruit second = new Fruit(0,0,0);
            for(int j = 0;j < n;j++){
                int id = cin.nextInt();
                int a = cin.nextInt();
                int b = cin.nextInt();
                Fruit fruit = new Fruit(a,b,id);
                if (a + b > max.getA() + max.getB()){
                    second = max;
                    max = fruit;
                } else if (a + b > second.getA() + second.getB()){
                    second = fruit;
                }
            }
            System.out.println(second.getId()+" "+second.getA()+" "+second.getB()+" "+(second.getA()+second.getB()));
        }

    }

    static class Fruit{
        private int a;
        private int b;
        private int id;

        public Fruit(int a, int b, int id) {
            this.a = a;
            this.b = b;
            this.id = id;
        }

        public int getA() {
            return a;
        }

        public int getB() {
            return b;
        }

        public int getId() {
            return id;
        }
    }

}

分享一个很坑爹的题：
4099:队列和栈
这个题坑爹之处在于你在输出error之后，还有继续处理完这次输入的余下内容

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int m = cin.nextInt();
        for (int i = 0;i < m;i++){
            int n = cin.nextInt();
            Stack<Integer> stack = new Stack<>();
            Queue<Integer> queue = new LinkedList<>();
            int j = 0;
            for (j = 0;j < n;j++){
                String opereation = cin.next();
                if (opereation.equals("push")){
                    int num = cin.nextInt();
                    stack.push(num);
                    queue.add(num);
                } else {
                    if (stack.empty()){
                        System.out.println("error");
                        System.out.println("error");
                        while(j < n){
                            cin.nextLine();
                            j++;
                        }
                        j = 0;
                        break;
                    } else {
                        stack.pop();
                        queue.poll();
                    }
                }
            }

            if (j == n){
                while (!queue.isEmpty()){
                    System.out.print(queue.poll()+" ");
                }
                System.out.print("\n");

                Stack<Integer> ans = new Stack<>();
                while(!stack.empty()){
                    ans.push(stack.pop());
                }
                while(!ans.empty()){
                    System.out.print(ans.pop()+" ");
                }
                System.out.print("\n");
            }
        }
    }
}

2020.1.21
4100:进程检测

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int m = cin.nextInt();
        for (int i = 0;i < m;i++){

            int n = cin.nextInt();
            int count = 0;
            Progress[] progresses = new Progress[n];
            for (int j = 0;j < n;j++){
                int start = cin.nextInt();
                int end = cin.nextInt();
                Progress progress = new Progress(start,end);
                progresses[j] = progress;
            }
            Arrays.sort(progresses, new Comparator<Progress>() {
                @Override
                public int compare(Progress o1, Progress o2) {
                    return o1.getStartTime() - o2.getStartTime();
                }
            });

            int left = 0;
            while(left < n){
                Progress progress = progresses[left];
                int right = left + 1;
                while (right < n){
                    Progress temp = progresses[right];
                    if (temp.getStartTime() > progress.getEndTime()){
                        break;
                    } else {
                        progress.setStartTime(temp.getStartTime());
                        progress.setEndTime(Math.min(progress.getEndTime(),temp.getEndTime()));
                    }
                    right++;
                }
                left = right;
                count++;
            }
            System.out.println(count);
        }
    }

    static class Progress{
        private int startTime;
        private int endTime;

        public Progress(int startTime, int endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
        }

        public int getStartTime() {
            return startTime;
        }

        public int getEndTime() {
            return endTime;
        }

        public void setStartTime(int startTime) {
            this.startTime = startTime;
        }

        public void setEndTime(int endTime) {
            this.endTime = endTime;
        }
    }
}

4101:晶矿的个数

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int m = cin.nextInt();
        for (int i = 0;i < m;i++){

            int n = cin.nextInt();
            cin.nextLine();
            char[][] grouds = new char[n][n];
            for (int j = 0;j < n;j++){
                String str = cin.nextLine();
                grouds[j] = str.toCharArray();
            }

            int red = findRed(grouds,n);
            int black = findBlack(grouds,n);
            System.out.println(red+" "+black);
        }
    }

    static int findRed(char[][] grouds,int n){
        int count = 0;
        for (int i = 0;i < n;i++){
            for (int j = 0;j < n;j++){
                if (grouds[i][j] == 'r'){
                    count++;
                    DFS(grouds,i,j,n,'r');
                }
            }
        }
        return count;
    }

    static int findBlack(char[][] grouds,int n){
        int count = 0;
        for (int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                if (grouds[i][j] == 'b'){
                    count++;
                    DFS(grouds,i,j,n,'b');
                }
            }
        }
        return count;
    }

    static void DFS(char[][] grouds,int i,int j,int n,char target){
        grouds[i][j] = '$';
        if (i > 0 && grouds[i - 1][j] == target){
            DFS(grouds,i - 1,j,n,target);
        }
        if (i < n - 1 && grouds[i + 1][j] == target){
            DFS(grouds,i + 1,j,n,target);
        }
        if (j > 0 && grouds[i][j - 1] == target){
            DFS(grouds, i, j - 1, n, target);
        }
        if (j < n - 1 && grouds[i][j + 1] == target){
            DFS(grouds, i, j + 1, n, target);
        }
    }

}

4103:踩方格
这一题要找规律

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int N = cin.nextInt();
        int y = 2;
        int ans = 3;
        for (int i = 1;i < N;i++){
            int temp = y;
            y = y + ans;
            ans = ans + 2 * temp;
        }
        System.out.println(ans);
    }

}

4104: 单词翻转

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        String input = cin.nextLine();
        char[] chars = input.toCharArray();
        int len = input.length();
        int left = 0;
        while (left < len){
            while (left < len && chars[left] == ' '){
                System.out.print(' ');
                left++;
            }
            int right = left;
            StringBuilder temp = new StringBuilder("");
            while (right < len && chars[right] != ' '){
                temp.append(chars[right]);
                right++;
            }
            left = right;
            System.out.print(temp.reverse());
        }
    }
}

4106:出现两次的字符-Characters Appearing twice

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        for (int i = 0;i < n;i++){
            Map<Character,Integer> count = new HashMap<>();
            String str = cin.next();
            char[] chars = str.toCharArray();
            for (char ch:chars){
                if (!count.containsKey(ch)){
                    count.put(ch,1);
                } else {
                    count.put(ch,count.get(ch) + 1);
                }
            }

            for (char ch:chars){
                if (count.get(ch) == 2){
                    System.out.println(ch);
                    break;
                }
            }
        }
    }
}

4139:不定方程求解

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int a = cin.nextInt();
        int b = cin.nextInt();
        int c = cin.nextInt();
        int count = 0;
        for (int i = c / a;i >= 0;i--){
            if ((c - a * i) % b == 0){
                count++;
            }
        }
        System.out.println(count);
    }
}

4142:二分法求函数的零点

import java.text.DecimalFormat;

public class Main {
    public static void main(String[] args) {
        DecimalFormat format = new DecimalFormat("0.000000");
        System.out.println(format.format(root()));
    }

    static double root(){
        double left = 1.5;
        double right = 2.4;
        while (right - left > 0.000001){
            double med = (left + right) / 2;
            double val = Math.pow(med,5) - 15 * Math.pow(med,4) + 85 * Math.pow(med,3) - 225 * Math.pow(med,2) + 274 * med - 121;
            if (val > 0){
                left = med;
            } else {
                right = med;
            }
        }
        return right;
    }
}

4146:数字方格

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int a1;
        int a2;
        int a3;
        int max = 0;
        for (a1 = n;a1 >= 0;a1 --){
            for (a2 = n;a2 >= 0;a2--){
                for(a3 = n;a3 >= 0;a3--){
                    if ((a1 + a2) % 2 == 0 && (a2 + a3) % 3 == 0 && (a1 + a2 + a3) % 5 == 0){
                        max = Math.max(max,a1 + a2 + a3);
                    }
                }
            }
        }
        System.out.println(max);
    }
}

4151:电影节

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        while (n != 0){
            Movie[] movies = new Movie[n];
            for (int i = 0;i < n;i++){
                int start = cin.nextInt();
                int end = cin.nextInt();
                Movie movie = new Movie(start,end);
                movies[i] = movie;
            }

            int index = 0;
            int count = 0;
            while (true){
                int minend = 2000;
                for (Movie movie:movies){
                    if (movie.getStartTime() >= index){
                        minend = Math.min(minend,movie.getEndTime());
                    }
                }
                if (minend == 2000){
                    break;
                } else {
                    count++;
                    index = minend;
                }
            }
            System.out.println(count);
            n = cin.nextInt();
        }
    }

    static class Movie{
        int startTime;
        int endTime;

        public Movie(int startTime, int endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
        }

        public int getStartTime() {
            return startTime;
        }

        public int getEndTime() {
            return endTime;
        }
    }
}

4107:19岁生日礼物-Birthday Gift

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        for (int i = 0;i < n;i++){
            int x = cin.nextInt();
            String y = "" + x;
            if (x % 19 == 0 || y.contains("19")){
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }
}

2020.1.22
4108:羚羊数量-Number Of Antelope
半夜做这个，脑子不清醒这么简单的一道题绕了半天

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        //i是第几年，nums[i]表示第i年有多少只🐏
        int[] nums = new int[41];
        //i是🐏的岁数，ages[i]是这个年龄的🐏的个数
        int[] ages = new int[41];
        ages[0] = 1;
        for (int i = 0;i <= 40;i++){
            int sum = 0;
            //System.out.println("第"+i+"年-----------------------》");
            for (int count:ages){
                sum += count;
                //System.out.println(count);
            }
            nums[i] = sum;
            
            int born = 0;

            for (int j = 40;j > 0;j--){
                ages[j] = ages[j - 1];
            }

            for (int age = 3;age <= 40;age++){
                born += ages[age];
            }
            ages[0] = born;
        }
        
        int n = cin.nextInt();
        for (int i = 0;i < n;i++){
            int x = cin.nextInt();
            //key是羚羊的年龄，value是这个年龄的领养的数量
            System.out.println(nums[x]);
        }
    }
}

4109:公共朋友-Common Friends

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int c = cin.nextInt();
        for (int i = 0;i < c;i++){
            System.out.println("Case "+(i + 1)+":");
            int n = cin.nextInt();
            int m = cin.nextInt();
            int k = cin.nextInt();
            Map<Integer,Set<Integer>> friends = new HashMap<>();
            for (int j = 1;j <= n;j++){
                Set<Integer> friend = new HashSet<>();
                friends.put(j,friend);
            }
            for (int j = 0;j < m;j++){
                int f1 = cin.nextInt();
                int f2 = cin.nextInt();
                friends.get(f1).add(f2);
                friends.get(f2).add(f1);
            }

            for (int j = 0;j < k;j++){
                int f1 = cin.nextInt();
                int f2 = cin.nextInt();
                Set<Integer> friends1 = friends.get(f1);
                Set<Integer> friends2 = friends.get(f2);
                int count = 0;
                if (friends1.size() <= friends2.size()){
                    for (int friend:friends1){
                        if (friends2.contains(friend)){
                            count++;
                        }
                    }
                } else {
                    for (int friend:friends2){
                        if (friends1.contains(friend)){
                            count++;
                        }
                    }
                }
                System.out.println(count);
            }
        }
    }
}

4110:圣诞老人的礼物-Santa Clau’s Gifts

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int weight = cin.nextInt();
        Candy[] candies = new Candy[n];
        for (int i = 0;i < n;i++){
            int v = cin.nextInt();
            int w = cin.nextInt();
            Candy candy = new Candy(w,v);
            candies[i] = candy;
        }
        Arrays.sort(candies, new Comparator<Candy>() {
            @Override
            public int compare(Candy o1, Candy o2) {
                double price1 = (double)o1.getValue() / o1.getWeight();
                double price2 = (double)o2.getValue() / o2.getWeight();
                if (price1 > price2){
                    return -1;
                } else if (price1 == price2){
                    return 0;
                } else {
                    return 1;
                }
            }
        });

        float sum = 0;
        int index = 0;
        while (weight > 0 && index < n){
            int min = Math.min(weight,candies[index].getWeight());
            float price = (float)candies[index].getValue() / candies[index].getWeight();
            sum += min * price;
            weight -= min;
            index++;
        }
        System.out.println(sum);
    }

    static class Candy{
        int weight;
        int value;

        public Candy(int weight, int value) {
            this.weight = weight;
            this.value = value;
        }

        public int getWeight() {
            return weight;
        }

        public int getValue() {
            return value;
        }
    }
}

4111:判断游戏胜者-Who Is the Winner

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        for (int i = 0;i < n;i++){
            String alice = cin.next();
            String bob = cin.next();
            compute(alice,bob);
        }
    }

    static void compute(String alice,String bob){
        int num1 = oneNum(alice);
        int num2 = oneNum(bob);
        if (num1 > num2){
            System.out.println("Alice");
        } else if (num1 < num2){
            System.out.println("Bob");
        } else {
            System.out.println("Tie");
        }
    }

    static String transfer(String str){
        int len = str.length();
        char[] chars = str.toCharArray();
        StringBuilder ans = new StringBuilder("");
        for (int i = 2;i < len;i++){
            char ch = chars[i];
            switch (ch){
                case '0':{
                    ans.append("0000");
                    break;
                }
                case '1':{
                    ans.append("0001");
                    break;
                }
                case '2':{
                    ans.append("0010");
                    break;
                }
                case '3':{
                    ans.append("0011");
                    break;
                }
                case '4':{
                    ans.append("0100");
                    break;
                }
                case '5':{
                    ans.append("0101");
                    break;
                }
                case '6':{
                    ans.append("0110");
                    break;
                }
                case '7':{
                    ans.append("0111");
                    break;
                }
                case '8':{
                    ans.append("1000");
                    break;
                }
                case '9':{
                    ans.append("1001");
                    break;
                }
                case 'a':{
                    ans.append("1010");
                    break;
                }
                case 'b':{
                    ans.append("1011");
                    break;
                }
                case 'c':{
                    ans.append("1100");
                    break;
                }
                case 'd':{
                    ans.append("1101");
                    break;
                }
                case 'e':{
                    ans.append("1110");
                    break;
                }
                case 'f':{
                    ans.append("1111");
                    break;
                }
            }
        }
        return ans.toString();
    }

    static int oneNum(String str){
        String str1 = transfer(str);
        char[] chars = str1.toCharArray();
        int len =  str1.length();
        int count = 0;
        int left = 0;
        while (left < len){
            while (left < len && chars[left] == '0'){
                left++;
            }
            if (left < len){
                count++;
            }
            int right = left + 1;
            while (right < len && chars[right] == '1'){
                right++;
            }
            left = right;
        }
        return count;
    }

}

4112:情报破译-Cryptanalysis

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()){
            String msg = cin.nextLine();
            int count = 0;
            char[] chars = msg.toCharArray();
            int len = msg.length();
            int left = 0;
            while (left < len){
                count++;
                while (left < len && !legal(chars[left])){
                    System.out.print(chars[left]);
                    left++;
                }
                StringBuilder word = new StringBuilder("");
                int right = left;
                while (right < len && legal(chars[right])){
                    word.append(chars[right]);
                    right++;
                }
                System.out.print(reverse(word.toString(),count));
                left = right;
            }
            System.out.print("\n");
        }
    }

    static String reverse(String string,int i){
        StringBuilder ans = new StringBuilder("");
        char[] chars = string.toCharArray();
        for (char ch:chars){
            char ch1;
            if (ch >= 'a' && ch <= 'z'){
                ch1 = (char)('a' + ((ch - 'a') - i + 26) % 26);
            } else {
                ch1 = (char)('A' + ((ch - 'A') - i + 26) % 26);
            }
            ans.append(ch1);
        }
        ans.reverse();
        return ans.toString();
    }

    static boolean legal(char ch){
        return (ch <= 'z' && ch >= 'a') || (ch >= 'A' && ch <= 'Z');
    }
}

2020.1.25
大年初一，希望今年平平安安，身体健康，万事如意

4117:简单的整数划分问题

这一题用到dp，new一个二维数组，dp[i][j]其中i表示我们要求的是加起来为i的结果，j表示开头第一个数是j
dp真的是需要积累的

import java.util.Scanner;

public class Main {

    private static int[][] dp = new int[51][51];

    static void initDp(){
        dp[0][0] = 1;
        dp[1][1] = 1;
        for (int i = 1;i <= 50;i++){
            for (int j = 1;j <= i;j++){
                int sum = 0;
                for (int k = 0;k <= j ;k++){
                    sum += dp[i - j][k];
                }
                dp[i][j] = sum;
            }
        }
    }

    public static void main(String[] args) {
        initDp();
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()){
            int input = cin.nextInt();
            int sum = 0;
            for (int i = 1;i <= input;i++){
                sum += dp[input][i];
            }
            System.out.println(sum);
        }
    }

}

4118:开餐馆
基础dp，用dp[i]表示最后一个选择第i个参观所带来的收益， 我不明白我的程序为什么会超时，我的时间复杂度明明是不会超时的，我感觉是测试用例有问题,这道题把我整放弃了，我还是回去做leetcode了，此博客暂时完结

import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int T = cin.nextInt();
        for (int i = 0;i < T;i++){
            int n = cin.nextInt();
            int distance = cin.nextInt();
            int[] dis = new int[n];
            int[] value = new int[n];
            for (int j = 0;j < n;j++){
                dis[j] = cin.nextInt();
            }
            for (int j = 0;j < n;j++){
                value[j] = cin.nextInt();
            }
            
            int max = 0;
            int[] dp = new int[n];
            for (int j = 0;j < n;j++){
                int temp = value[j];
                int index = 0;
                while(dis[j] - dis[index] > distance){
                    temp = Math.max(temp,value[j] + dp[index]);
                    index++;
                }
                dp[j] = temp;
                max = Math.max(max,dp[j]);
            }
            System.out.println(max);
        }
    }

}

2020.2.18
这瘟疫啥时候能过去。。。

4137:最小新整数：这个问题开始想难了，其实不难

import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int t = cin.nextInt();
        for (int i = 0;i < t;i++){
            String n = cin.next();
            int len = n.length();
            int k = cin.nextInt();
            int count = 0;
            Stack<Character> stack = new Stack<>();
            char[] chars = n.toCharArray();
            for (char ch:chars){
                while (!stack.empty() && ch < stack.peek() && count < k){
                    stack.pop();
                    count++;
                }
                stack.push(ch);
            }

            Stack<Character> temp = new Stack<>();
            while (!stack.empty()){
                temp.add(stack.pop());
            }
            StringBuilder stringBuilder = new StringBuilder("");
            for (int j = 0;j < len - k;j++){
                stringBuilder.append(temp.pop());
            }
            System.out.println(stringBuilder.toString());
        }
    }
}

签到题：
4138:质数的和与积

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int left = n / 2;
        while(left > 1){
            int right = n - left;
            if (illegal(left) && illegal(right)){
                System.out.println(left * right);
                break;
            }
            left--;
        }
    }

    static boolean illegal(int x){
        int y = (int)Math.sqrt(x);
        for (int i = 2;i <= y;i++){
            if (x % i == 0){
                return false;
            }
        }
        return true;
    }
}

4147:汉诺塔问题(Hanoi)
老经典题了
汉诺塔问题的思路是这样的：
在这里插入图片描述
有n个大铁片子要从a借助b到达c，我们记为 F ( n , a , b , c ) F(n,a,b,c) F(n,a,b,c)
事实上，为了完成这个任务，我们必须要经过一个中间状态，那就是将前n-1个铁片放在b上，完了让第n个从a放在c上
那么问题变成这样：
要完成把n个铁片从a借助b到达c，需要分为三步：

  1. 把n-1个铁片从a借助c放到b上
  2. 把a上第n个铁片放在c上
  3. 把b上n-1个铁片借助a放在c上
    我们进行抽象：
    F ( n , a , b , c ) = F ( n − 1 , a , c , b ) − > 把 n 从 a 放 到 c 上 − > F ( n − 1 , b , a , c ) F(n,a,b,c)=F(n-1,a,c,b)->把n从a放到c上->F(n-1,b,a,c) F(n,a,b,c)=F(n−1,a,c,b)−>把n从a放到c上−>F(n−1,b,a,c)
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        char a = cin.next().charAt(0);
        char b = cin.next().charAt(0);
        char c = cin.next().charAt(0);
        hanno(n,a,b,c);
    }

    static void hanno(int n,char a,char b,char c){
        if (n == 1){
            System.out.println(n + ":" + a + "->" + c);
        } else {
            hanno(n - 1,a,c,b);
            System.out.println(n + ":" + a + "->" + c);
            hanno(n - 1,b,a,c);
        }
    }
}

2020.2.19
做一个简单的一批的题目居然难住了：
836. 矩形重叠
如果连个矩阵 ( x 1 , y 1 , x 2 , y 2 ) , ( x 3 , y 3 , x 4 , y 4 ) (x1,y1,x2,y2),(x3,y3,x4,y4) (x1,y1,x2,y2),(x3,y3,x4,y4)要相交，那么他们俩相交的矩阵就是 ( m a x ( x 1 , x 3 ) , m a x ( y 1 , y 3 ) , m i n ( x 2 , x 4 ) , m i n ( y 2 , y 4 ) ) (max(x1,x3),max(y1,y3),min(x2,x4),min(y2,y4)) (max(x1,x3),max(y1,y3),min(x2,x4),min(y2,y4))
我们只需要判断这个能不能构成举行就可以了

    public boolean isRectangleOverlap(int[] rec1, int[] rec2) {
        int x5 = Math.max(rec1[0],rec2[0]);
        int y5 = Math.max(rec1[1],rec2[1]);
        int x6 = Math.min(rec1[2],rec2[2]);
        int y6 = Math.min(rec1[3],rec2[3]);
        return x5 < x6 && y5 < y6;
    }

2020.2.20

4127:迷宫问题

啊这个问题有一点点意思的
BFS+DP
题目要求我们从左上角向右下角去找一条路，但是我们要反过来想，从右下角向左上角去找路，所以我们从右下角开始BFS，记录每个位置到右下角所需的最短路径，最后我们从左上角开始输出就可以了。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[][] matrix = new int[5][5];
        int[][] length = new int[5][5];
        Scanner cin = new Scanner(System.in);
        for (int i = 0;i < 5;i++){
            for (int j = 0;j < 5;j++){
                matrix[i][j] = cin.nextInt();
                length[i][j] = Integer.MAX_VALUE;
            }
        }

        BFS(matrix,length);

        print(length,0,0);
    }

    static void print(int[][] length,int i,int j){
        System.out.println("(" + i + ", " + j + ")");
        int len = length[i][j];
        if (i > 0 && length[i - 1][j] == len - 1) {
            print(length, i - 1, j);
        }
        if (i < 4 && length[i + 1][j] == len - 1){
            print(length, i + 1, j);
        }
        if (j > 0 && length[i][j - 1] == len - 1) {
            print(length, i, j - 1);
        }
        if (j < 4 && length[i][j + 1] == len - 1) {
            print(length, i, j + 1);
        }
    }

    static void BFS(int [][] matrix,int[][] length){
        int count = 1;
        List<Point> points = new ArrayList<>();
        points.add(new Point(4,4));
        length[4][4] = 0;
        while (!points.isEmpty()){
            List<Point> points1 = new ArrayList<>();
            for (Point point:points){
                int x = point.x;
                int y = point.y;
                if (x > 0 && matrix[x - 1][y] == 0 && length[x - 1][y] == Integer.MAX_VALUE){
                    length[x - 1][y] = count;
                    points1.add(new Point(x - 1,y));
                }
                if (y > 0 && matrix[x][y - 1] == 0 && length[x][y - 1] == Integer.MAX_VALUE){
                    length[x][y - 1] = count;
                    points1.add(new Point(x,y - 1));
                }
                if (x < 4 && matrix[x + 1][y] == 0 && length[x + 1][y] == Integer.MAX_VALUE){
                    length[x + 1][y] = count;
                    points1.add(new Point(x + 1,y));
                }
                if (y < 4 && matrix[x][y + 1] == 0 && length[x][y + 1] == Integer.MAX_VALUE){
                    length[x][y + 1] = count;
                    points1.add(new Point(x,y + 1));
                }
            }
            count++;
            points = points1;
        }
    }


    static class Point{
        private int x;
        private int y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
        }
    }

}

4122:切割回文

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int T = cin.nextInt();
        for (int i = 0;i < T;i++){
            String string = cin.next();
            char[] chars = string.toCharArray();
            int len = string.length();
            System.out.println(getCount(chars,0,len - 1));
        }
    }

    static int getCount(char[] chars,int left,int right){
        if (left > right){
            return -1;
        }
        int index = left;
        while (!islegal(chars,index,right)){
            index++;
        }
        return 1 + getCount(chars, left, index - 1);
    }

    static boolean islegal(char[] chars,int left,int right){
        while (left < right){
            if(chars[left] != chars[right]){
                return false;
            } else {
                left++;
                right--;
            }
        }
        return true;
    }

}

2020.2.22
狗日的瘟疫

leetcode60：第k个排列

    public String getPermutation(int n, int k) {
        int t = n;
        k--;
        int[] nums = new int[n];
        boolean[] chosen = new boolean[n];
        StringBuilder stringBuilder = new StringBuilder("");

        for (int i = 1;i <= n;i++){
            nums[i - 1] = i;
        }

        while (t > 0){
            t--;
            int s = k / fx(t);
            int count = 0;
            int i = 0;

            for (;i < n;i++){
                if (!chosen[i]){
                    count++;
                }
                if (count > s){
                    break;
                }
            }

            stringBuilder.append(nums[i]);
            chosen[i] = true;
            k -= s * fx(t);
        }
        return stringBuilder.toString();
    }

    static int fx(int x){
        int ans = 1;
        for (int i = 2;i <= x;i++){
            ans *= i;
        }
        return ans;
    }
canaryW
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[宫水三叶的刷题日记]：数学1
08-03
2. 从侧边栏的类别目录找到「数学」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检索 1
[宫水三叶的刷题日记]：括号问题1
08-03
【宫水三叶的刷题日记】：括号问题1主要关注的是编程中的括号匹配问题，这是一个常见的算法问题，特别是在Java编程语言中。该问题通常出现在LeetCode等在线编程平台的练习题目中，用于测试和提升程序员的逻辑思维与...
刷题日记
AnthonyM08的博客
01-26 231
001 - 斐波那契数列 class Solution { public: int Fibonacci(int n) { if(n==0) return 0; if(n==1 || n==2) return 1; else{ int i=1,j=1,sum; for(int k=3;k<=n;k++){ sum=i+j
我的刷题日记（6）
shijie
09-21 111
题目描述 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。 首先得清楚怎么求一个整数的二进制？ 什么是原码，反码，补码？ 比如用四位的二进制数表示1 ，则为0001 正数的原码：第一位是0（符号位）表示正数0001 负数的原码：第一位是1表示负数。1001 正数的 : 原码 = 反码 = 补码 负数的反码： 符号位不变其余取反。1变为0，0变为1。 1001 => 1110 ...
LeetCode刷题日记精选例题（详细解析+代码+链接）
wenwenaier的博客
11-27 1303
文章目录一、字符替换二、翻转字符串里的单词三、左旋转字符串（剑指Offer）四、实现strStr()五、重复的子字符串 一、字符替换 来源：leetcode 题目链接 创建StringBuilder对象（StringBuffer也可以），在遍历的时候进行判断，是空格则替换并加到StringBuilder后面，不是空格则直接加入 public static String replaceSpace(String s) { if (s==null){ retu
LeetCode刷题日记精选例题（附代码+链接）
wenwenaier的博客
11-25 1208
文章目录一、有效字母的异同词二、数组交集三、快乐数四、两数之和五、三数之和六、四数之和七、四数相加八、赎金信九、反转字符串十、反转字符串2 一、有效字母的异同词 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词 来源：力扣（LeetCode） 链接： 题目链接 解题思路： 因为此题暴力破解的时间复杂度较高，所以我们采用下面的方式 创建一个数组，记录每个字母出现的次数，对s中的每个字符进行
Bailian4095 打字员【文本】
海岛Blog
09-11 1273
4095:打字员 总时间限制: 1000ms 内存限制: 65536kB 描述 有一个打字员,他打字的时候有个习惯,从来不用 Shift 来切换大小写,只用 Caps Lock。 现在给他一个地铁站的名字,你需要写一个程序来告诉他,他需要敲击多少下键盘才能打出 这个地铁站名。 输入 第一行输入一个数字 n (n<1000),表示共有多少个需要处理的车站名。从第 2 到第 n+1 行是这 n 个车站名。车站名由英文字母构成,名字的长度不会超过 100 个字符。已知开始时 键盘是输入小写字母的状态。 输出
2020 算法刷题日记
算法channel
11-29 265
我们说刷题最重要的部分是分析过程，至于答案网上有很多，可以自行去查询。欢迎加入 zhenguo 的 算法刷题日记 星球，加入这里你能获得什么：过往100多天刷题完整分析和答案PDF目前星...
2022年1月20日刷题日记
01-21
在今天的刷题日记中，我们关注了几个与JavaScript相关的LeetCode题目，涉及到的主要知识点包括数据结构、算法和问题解决策略。首先，我们来看看217. 存在重复元素的问题，这是一个关于数组中是否存在重复元素的判断...
[宫水三叶的刷题日记]：n 数之和1
08-03
【宫水三叶的刷题日记】：n 数之和1 这个主题主要涉及到的是在编程刷题中处理数组中三个元素之和的问题。在LeetCode等在线编程平台上，这类问题通常与算法和数据结构相关，特别是涉及到数组操作、排序和双指针技巧。...
[宫水三叶的刷题日记]：（图论）拓扑排序1
08-03
《宫水三叶的刷题日记》系列是关于算法学习的原创专题，专注于图论中的拓扑排序。本文主要讨论了如何使用拓扑排序解决LeetCode上的问题——找到最终的安全状态。拓扑排序是一种在有向无环图（DAG，Directed Acyclic ...
Bailian4101 晶矿的个数【DFS】
海岛Blog
09-04 583
4101:晶矿的个数 总时间限制: 1000ms 内存限制: 65536kB 描述 在某个区域发现了一些晶矿，已经探明这些晶矿总共有分为两类，为红晶矿和黑晶矿。现在要统计该区域内红晶矿和黑晶矿的个数。假设可以用二维地图m[][]来描述该区域，若m[i][j]为#表示该地点是非晶矿地点，若m[i][j]为r表示该地点是红晶矿地点，若m[i][j]为b表示该地点是黑晶矿地点。一个晶矿是由相同类型的并且上下左右相通的晶矿点组成。现在给你该区域的地图，求红晶矿和黑晶矿的个数。 输入 第一行为k，表示有k组测试输入。
百练分类题解
海岛Blog
05-25 4961
问题链接：HDU1003 Max Sum。 问题简述：参见上述链接。 问题分析：计算最大子段和问题，是一个经典的动态规划问题。 程序说明：这个算法可以说是最为快速简洁的算法，其计算复杂度为O(n)，而且没有使用存储空间来存储序列数据。 题记：（略） AC的C++语言程序如下： /* HDU1003 Max Sum */ #include using nam
牛客刷题日记（2021-11-19）
LEO
11-19 1148
牛客刷题日记（2021-11-2） 题目： 关于类的叙述正确的是（）。 A.在类中定义的变量称为类的成员变量，在别的类中可以直接使用 B.局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中 C.使用别的类的方法仅仅需要引用方法的名字即可 D.只要没有定义不带参数的构造函数，JVM都会为类生成一个默认构造函数 解析： 正确答案：B 【解析】 A在类中定义的变量称为类的成员变量，在别的类中不可以直接使用局部变量的 C使用别的类的方法需要通过该类的对象引用方法的名字 D只要没有定义任何构造函数，
财务收支管理系统(自动统计，智能查询，).xlsm
08-13
工资表，财务报表，对账表，付款申请，财务报告，费用支出表，财务收支 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
核电站建设和运营 头豹词条报告系列.pdf
最新发布
08-13
电子元件 电子行业 行业分析 数据分析 数据报告 行业报告
户用储能 头豹词条报告系列.pdf
08-13
电子元件 电子行业 行业分析 数据分析 数据报告 行业报告
CSDN是一个中文资讯技术知识服务网站.docx
08-13
CSDN（Chinese Software Developer Network），即中国软件开发者网络，是一个中文资讯技术知识服务网站，隶属于北京创新乐知网络技术有限公司。以下是对CSDN的详细介绍： 一、基本概况 成立时间：CSDN创立于1999年，是国内较早的IT技术社区之一。 总部地点：北京 经营范围：主要提供技术资讯、开发工具、社区交流、在线学习、职业发展等全生命周期服务。 公司类型：股份制 CEO：蒋涛 二、主要业务与产品 技术社区：CSDN拥有全球最大的中文IT技术社区CSDN.NET，为开发者提供文章、博客、问答、课程等丰富的内容资源。 移动端应用：开发了CSDN APP和CSDN学院APP，为移动端开发者提供便捷的技术资讯和学习平台。 新媒体矩阵：包括微信公众号（如CSDN资讯、程序人生、GitChat等）和微博等，形成多渠道、全方位的信息传播网络。 在线学习平台：CSDN学院作为在线学习平台，集合了各领域资深技术专家，提供优质的在线课程和技术直播。 技术知识移动社区：GitChat作为技术知识移动社区，为开发者和互联网从业者打造了一个高品质的内容社区。 IT人力资源
智慧酒店项目智能化系统汇报方案.pptx
08-13
智慧酒店项目智能化系统汇报方案.pptx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

canaryW

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

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

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

打赏作者

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

抵扣说明：

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

余额充值