算法第一周——洛谷

# 洛谷算法

## P5704字母转换

属于是基础不够扎实，怕以后再忘记，打个笔记

每个字母都对应一个ASCII码，如果不知道可以

~~~java

public class transformation {

public static void main(String[] args) {

System.out.println((int)('a')-(int)('A'));

//用int强制转换将字符A，a转换为ASCII码，得出大小写字母的差值为32

//(int)('a')-32=(int)('A');

}

~~~

接下来接受键盘输入的小写字母，将其转换为ASCII 码，减32输出即可

~~~java

import java.util.Scanner;

public class transformation {

public static void main(String[] args) {

int dif = (int)('a')-(int)('A');//ASCII差值dif

Scanner cin = new Scanner(System.in);

String a = cin.next();

char A=' ';//连接循环内外的桥梁

for (int i = 0; i < a.length(); i++) {

char ch = a.charAt(i);//字符串转换为单个字符

ch = (char) ((int) ch - dif);//大小写进行转换

A=ch;

}

System.out.println(A);

}

~~~

很抱歉，在scanner中并没有找到接受char类型的方法，只能通过String——>char——>int——>char的方式进行

## P5705数字反转

第一次硬做，错误，可以尝试一下取余法，但是感觉还是很麻烦

~~~java

import java.util.Scanner;

public class numtransformation {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

float m = cin.nextFloat();

int b = (int)m/100;

int s = (int)(m-b*100)/10;

int g = (int)(m-b*100-s*10);

float h = m-b*100-s*10-g;

float f = h*1000+g*10+s+(float) b/10;

System.out.println(f);

}

~~~

难道和字母转化一样也是，将数字转化为字符，然后反转顺序输出，不对！数字好像也可以是字符

~~~java

import java.util.Scanner;

public class numtransformation {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

String str = cin.next();

for (int i = str.length()-1; i >= 0; i--) {

char ch = str.charAt(i);

System.out.print(ch);

}

~~~

网络上的答案

~~~java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

char[] chars = scanner.nextLine().toCharArray();

for (int i = chars.length-1; i >= 0; i--) {

System.out.print(chars[i]);

}

scanner.close();

}

//原文链接：https://blog.csdn.net/weixin_43896318/article/details/104230193

~~~

## P5706分水

觉得比较简单

~~~java

import java.util.Scanner;

public class Waterdiversion {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

float t = cin.nextFloat();

int n = cin.nextInt();

System.out.println(t/n);

System.out.print(2*n);

}

~~~

结果答案里的第一行太长了，严格保证保留三位小数于是

~~~java

import java.util.Scanner;

public class Waterdiversion {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

float t = cin.nextFloat();

int n = cin.nextInt();

Double d = Double.valueOf(String.format("%.3f", t/n));

//这是保留三位小数的方法吧

System.out.println(d);

System.out.print(2*n);

}

~~~

## P1425小鱼游泳

~~~java

import java.util.Scanner;

public class Swimrace {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int

a=cin.nextInt(),

b=cin.nextInt(),

c=cin.nextInt(),

d=cin.nextInt();

int e,f;

if (d>=b){

e=c-a;

f=d-b;

}else {

e=c-a-1;

f=60-b+d;

}

System.out.print(e+" "+f);

}

~~~

# P5708 【深基2.习2】三角形面积

Math类中的sqrt方法是求开方，sqrt（double n）其中的n是要开方的数

~~~java

import java.util.Scanner;

public class triangle {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

float a=cin.nextFloat(),b=cin.nextFloat(),c=cin.nextFloat();

double p=1.0/2*(a+b+c);

double area = Math.sqrt(p*(p-a)*(p-b)*(p-c));

System.out.println(area);

}

~~~

要求保留小数的说

Double.valueOf的作用是将String或者其他数据类型转化为Double类型，取其数值，若是其他的则会报错

~~~java

import java.util.Scanner;

public class triangle {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

double a=cin.nextDouble(),b=cin.nextDouble(),c=cin.nextDouble();

double p=0.5*(a+b+c);

System.out.println(Double.valueOf(String.format("%.1f",Math.sqrt(p*(p-a)*(p-b)*(p-c)))));

}

~~~

# P2181 对角线

这是一个数学问题，我整理了一下我现在能推的数据，像是n边形就有n个顶点，每个顶点所拥有的对角线除去本顶点和相邻顶点，每个顶点有n-3条对角线，每条对角线有两个顶点，所以n边形的对角线有(n-3)*n/2条，但是没有向交点上想，没写出来

推导过程为：任意三条对角线不会只有一个交点，也就是过一个交点的对角线固定有两条，两条对角线对应四个顶点，那么任意四个顶点能够确定一个交点，现在就从规律寻找问题转变成了排列组合的问题，当n>=4时，交点数是Cn|4，即4!/n!

对于计算时

~~~Java

import java.math.BigInteger;

import java.util.Scanner;

public class Diagonal {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int n = cin.nextInt();

int m=1;

int dian = 4*3*2*1;

if (n>=4)

{

for (int i = 0; i < 4; i++) {

m*=n;

n-=1;

}

System.out.println(m/dian);

}else

System.out.println(0);

}

~~~

![image-20220111083526324](C:\Users\haozh\AppData\Roaming\Typora\typora-user-images\image-20220111083526324.png)题目中的100%的数据![image-20220111083620557](C:\Users\haozh\AppData\Roaming\Typora\typora-user-images\image-20220111083620557.png)

可见int似乎不行，使用long也仅仅能够从55提升到82.计算大数可以用Biginteger类

![img](https://img-blog.csdn.net/20160823162406249)

修改后

~~~Java

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

BigInteger n = cin.nextBigInteger();

BigInteger Two = BigInteger.valueOf(2);

BigInteger Three = BigInteger.valueOf(3);

BigInteger TF = BigInteger.valueOf(24);

System.out.println(n.multiply(n.subtract(BigInteger.ONE)).multiply(n.subtract(Two).multiply(n.subtract(Three))).divide(TF));

}

~~~

BigInteger有TWO但是为private拒绝访问，自己又添了一个

# P5707 【深基2.例12】上学迟到

~~~java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

Float s = cin.nextFloat(),v = cin.nextFloat();

int least = 32*60;

int time = (int) Math.ceil(s/v+10);

int hours = time/60;

int hh,mm = (least-time)%60;

if (hours<8){

hh = (least-time)/60-24;

System.out.println("0"+hh+":"+mm);

}else {

hh = (least-time)/60;

System.out.println(hh+":"+mm);

}

~~~

Java通常向下取整，1.1=1.0，ceil方法用于向上取整1.1=2.0，这道题感觉写的不是特别地道

# P5710 【深基3.例2】数的性质

~~~Java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

int x = new Scanner(System.in).nextInt();

int xiaoA = 0, Uim = 0, bawei = 0, zhengmei = 0;

boolean ou = x%2==0;

boolean fanwei = x>4&&x<=12;

if (ou&&fanwei)

xiaoA = 1;

if ((ou||fanwei)||(ou&&fanwei))

Uim = 1;

if ((ou&&!fanwei)||(!ou&&fanwei))

bawei = 1;

if (!ou&&!fanwei)

zhengmei = 1;

System.out.println(xiaoA+" "+Uim+" "+bawei+" "+zhengmei);

}

~~~

![img](https://images2015.cnblogs.com/blog/1064302/201612/1064302-20161219192127307-1349816173.png)记住这张表就可以，各种条件太多了就搞乱了，费了不少时间

# P1085 [NOIP2004 普及组] 不高兴的津津

~~~java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin=new Scanner(System.in);

int[] school = new int[7];

int[] home = new int[7];

int[] sum = new int[7];

for (int i = 0; i < 7; i++) {

school[i]=cin.nextInt();

home[i]=cin.nextInt();

sum[i]=school[i]+home[i];

}

int temp = 0;

for (int i = 0; i < sum.length; i++) {

if (sum[i]>temp)

temp=sum[i];

}

int day = 0;

for (int i = 0; i < sum.length; i++) {

if (sum[i]==temp)break;

day=i+2;

}

System.out.println(day);

}

~~~

# P1424 小鱼的航程(改进版)

看似简单的题，用天数来分支需要考虑的太多，不太好想

我写的（错了），这里是正确写法，很长

~~~Java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int x = scanner.nextInt();

long n = scanner.nextLong();

long m = 0; //剩余天数

long result =0;//总公里数

if (7-x>=2){

result+=(5-x+1)*250;

}else {

result = 0;

}

m = n-(7-x+1);

if (m%7 == 0){

result += m/7*5*250;

} else if (m%7>=5){

result += ((m/7+1)*5)*250;

}else {

result += (m/7*5+m%7)*250;

}

System.out.println(result);

}

~~~

但是如果利用循环就可以一天一天的进行判断，让天数一天一天加，判断每一天是否为周末，是则不加公里数，不是则加公里数，在天数到了7时返回1继续判定

~~~java

import java.util.Scanner;

public class P1424 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int x = cin.nextInt(),n = cin.nextInt();

long km=0;

for (int i = 0; i < n; i++) {

if (x!=6&&x!=7){

km+=250;

}

if (x==7)

x=1;

else

x++;

}

System.out.println(km);

}

~~~

又好想又简洁

# P1888 三角函数

一开始，我知道Math里有求最大值和最小值的方法，但是提交上去错掉了，原因是分数要时最简的，像是14/21要写为3/2，然后就开始寻找求两个数的最大公约数的方法，

~~~java

import java.util.Scanner;

public class P1888 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int a = cin.nextInt(),b=cin.nextInt(),c=cin.nextInt();

System.out.println(Math.min(a,Math.min(b,c))+"/"+Math.max(a,Math.max(b,c)));

}

~~~

https://blog.csdn.net/yuemeicheng/article/details/81204864

这里讲了三种最大公约数的方法：1.辗转相减法；2.穷举法；3.辗转相除法，我在这里用了最短的一个（最好都会用）

~~~Java

import java.util.Scanner;

public class P1888 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int a = cin.nextInt(),b=cin.nextInt(),c=cin.nextInt();

int min=Math.min(a,Math.min(b,c)),max=Math.max(a,Math.max(b,c));

int m = max,n = min;

while((m-n)!=0) {

if(m>n) {

m = m-n;

}else {

n = n-m;

}

max/=m;

min/=n;

System.out.println(min+"/"+max);

}

~~~

# P5717 【深基3.习8】三角形分类

根据题示可以知道首先要对输入的三条边进行排序，然后进行类别判定，对于只有三个的排序也可以用Math.min来做，但在这里想到了昨天学长说的Collaborations.sort（），虽然写起来有点不伦不类感觉很麻烦，但就当练手了

~~~Java

import java.util.ArrayList;

import java.util.Collections;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

ArrayList m = new ArrayList(3);

int a = cin.nextInt(), b = cin.nextInt(), c = cin.nextInt();

m.add(a);

m.add(b);

m.add(c);

Collections.sort(m);

a = (int) m.get(0);

b = (int) m.get(1);

c = (int) m.get(2);

if (a + b <= c) {

System.out.println("Not triangle");

return;

}

if (a * a + b * b == c * c) System.out.println("Right triangle");

else if (a * a + b * b > c * c) System.out.println("Acute triangle");

else if (a * a + b * b < c * c) System.out.println("Obtuse triangle");

if (a == b || a == c || b == c) System.out.println("Isosceles triangle");

if (a == b && b == c) System.out.println("Equilateral triangle");

}

~~~

# P5721 【深基4.例6】数字直角三角形

像是这种写的很少却要想很久的题在状态不好的时候就是一大时间杀手，能够自己一次写对就很了不起，我没有

~~~Java

import java.util.Scanner;

public class P5721 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int n = cin.nextInt(), count = 1;//令count无论哪一次输出都+1

for (int i = 0; i < n; i++) {//外层循环控制行的数量

for (int j = 0; j < n-i; j++) {//内层循环控制行的输出

if (count < 10) {

System.out.print("0" + count);//补零

count++;

} else {

System.out.print(count);

count++;

}

System.out.println();

}

~~~

本题难想的点就是在于内外两层循环之间要加上联系，第1行要n-1+1个，第2行要n-2+1个，第3行要n-3+1个，外层循环i是从0开始增加，恰好被内层循环j减去就是本行数的数量

# P1009 [NOIP1998 普及组] 阶乘之和

一开始觉得很简单

~~~Java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int sum = 0,n = cin.nextInt();

for (int i = 1; i < n+1; i++) {

int temp=1;

for (int j = 1; j < i+1; j++) {

temp*=j;

}

sum+=temp;

}

System.out.println(sum);

}

~~~

然后int的精度就爆了换成long也不行，看来又要用BigInteger了

~~~Java

import java.math.BigInteger;

import java.util.Scanner;

public class P1009 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int n = cin.nextInt();

BigInteger sum = new BigInteger("0");

for (int i = 1; i < n + 1; i++) {

BigInteger temp = new BigInteger("1");

for (int j = 1; j < i + 1; j++) {

temp = temp.multiply(BigInteger.valueOf(j));

}

sum = sum.add(temp);

}

System.out.println(sum);

}

~~~

期间忘了写temp=和sum=，傻了傻了

看到了有人这样写

~~~Java

import java.util.Scanner;

public class test {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

if(n== 0) System.out.println("1");

if(n== 1) System.out.println("1");

if(n== 2) System.out.println("3");

if(n== 4) System.out.println("33");

if(n== 5) System.out.println("153");

if(n== 6) System.out.println("873");

if(n== 7) System.out.println("5913");

if(n== 8) System.out.println("46233");

if(n== 9) System.out.println("409113");

if(n==10) System.out.println("4037913");

if(n==11) System.out.println("43954713");

if(n==12) System.out.println("522956313");

if(n==13) System.out.println("6749977113");

if(n==14) System.out.println("93928268313");

if(n==15) System.out.println("1401602636313");

if(n==16) System.out.println("22324392524313");

if(n==17) System.out.println("378011820620313");

if(n==18) System.out.println("6780385526348313");

if(n==19) System.out.println("128425485935180313");

if(n==20) System.out.println("2561327494111820313");

if(n==21) System.out.println("53652269665821260313");

if(n==22) System.out.println("1177652997443428940313");

if(n==23) System.out.println("27029669736328405580313");

if(n==24) System.out.println("647478071469567844940313");

if(n==25) System.out.println("161586881sa373618851684940313");

if(n==29) System.out.println("9157958657951075573395300940313");

if(n==30) System.out.println("274410818470142134209703780940313");

if(n==31) System.out.println("8497249472648064951935266660940313");

if(n==32) System.out.println("271628086406341595119153278820940313");

if(n==33) System.out.println("894945705218228090637347680100940313");

if(n==34) System.out.println("304187744744822368938255957323620940313");

if(n==35) System.out.println("10637335711130967298604907294846820940313");

if(n==36) System.out.println("382630662501032184766604355445682020940313");

if(n==37) System.out.println("14146383753727377231082583937026584420940313");

if(n==38) System.out.println("537169001220328488991089808037100875620940313");

if(n==39) System.out.println("20935051082417771847631371547939998232420940313");

if(n==40) System.out.println("836850334330315506193242641144055892504420940313");

if(n==41) System.out.println("34289376947494122614363304694584807557656420940313");

if(n==42) System.out.println("1439295494700374021157505910939096377494040420940313");

if(n==43) System.out.println("0313");

if(n==44) System.out.println("0313");

if(n==45) System.out.println("0313");

if(n==46) System.out.println("0313");

if(n==47) System.out.println("0313");

if(n==48) System.out.println("12678163798554051767172643373255731925167694226950680420940313");

if(n==49) System.out.println("0313");

if(n==50) System.out.println("0313");

}

~~~

这也太猛了

# P1980 [NOIP2013 普及组] 计数问题

我的想法是一个count累加，然后把count转变为字符储存，然后在n的循环中和字符x进行相等的判定，相等则计数器temp++；大概这个意思

~~~Java

import java.util.Scanner;

public class P1980 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int n = cin.nextInt(), count = 1, temp = 0;

char x = cin.next().charAt(0);

for (int i = 0; i < n; i++) {

String str = String.valueOf(count);

for (int j = 0; j < str.length(); j++) {

char ch = str.charAt(j);

if (ch == x) {

temp++;

}

count++;

}

System.out.println(temp);

}

~~~

# P5723 【深基4.例13】质数口袋

感觉就是脑子不好使，做了一上午总算做出来了

~~~Java

import java.util.Scanner;

public class P5723 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int l = cin.nextInt(), sum = 0, count = 0;

for (int i = 2; i < 10000; i++) {//这一片的循环理得时候很乱，主要是顺序有一些错误

sum += isPrime(i);//无论是不是质数都加上去，因为isPrime的结果只有质数和零

if (sum>l)break;//这个判定的位置是最后一个错误，应该优先让for结束，若将此if放在下面的if后，则会多输出一个质数，count（质数数量也会多一个

if (isPrime(i) != 0) {

System.out.println(i);

count++;

}

System.out.println(count);

}

public static int isPrime(int num) {//这里是判断是否为质数的方法，是质数就返回本身，不是则返回0

if (num==0||num==1)return 0;

for (int i = 2; i < num; i++) {

if (num % i == 0) {

return 0;

}

return num;

}

~~~

# P1217 [USACO1.5]回文质数 Prime Palindromes

输入两个数来确定范围，在这个范围内找到所有回文质数并输出，首先要先找出质数，然后看质数是否为回文数，是的话输出，

如何判断一个数是否为回文数

这种方法像是贪吃蛇吃自己的尾巴，吃到头的时候，发现头从尾巴那里长了出来，简单来说就是y%10+y/10将各个位上的数取出累计到num中，最后对比看num和最初的x是否相等，x为521时，num每次的输出结果为1、12、125

~~~Java

import java.util.Scanner;

public class test {

public static void main(String[] args) {

int x = new Scanner(System.in).nextInt();

int y = x, num = 0;

while(y!=0){

num = num*10+y%10;

y/=10;

System.out.println(1%10);

}

if (num==x)

System.out.println(x+"是回文数");

else

System.out.println(x+"不是回文数");

}

~~~

对于将回文数的判定和质数的判定写在一个大类里我就不追求了，到时候我自己看不懂，别人看着也头疼，不至于花这么多时间

~~~Java

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int a = cin.nextInt(), b = cin.nextInt();

for (int i = a; i <= b; i++) {

if (isPalindrome(i)&&isPrime(i)) {

System.out.println(i);

}

public static boolean isPalindrome(int num) {

int a = 0, b = num;

boolean ret = false;

while (b != 0) {

a = a * 10 + b % 10;

b /= 10;

}

if (num == a)

ret = true;

return ret;

}

public static boolean isPrime(int num) {

boolean ret = true;

for (int i = 2; i <= Math.sqrt(num); i++) {

if (num % i == 0) {

ret = false;

break;

}

return ret;

}

~~~

超时超时超时，开始缩减计算量，还是不行，最后看了网上的做法，改了几处，603ms通过了，淦！！！

~~~Java

import java.util.Scanner;

public class P1217 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int a = cin.nextInt(), b = cin.nextInt();

for (int i = a; i <= b; i++) {

if (i != 2 && i != 3 && i != 5 && (i % 2 == 0 || i % 3 == 0 || i % 5 == 0)) {

continue;

}

if (isPalindrome(i)) {

if (isPrime(i)) {

System.out.println(i);

}

public static boolean isPalindrome(int num) {

int a = 0, b = num;

boolean ret = false;

while (b != 0) {

a = a * 10 + b % 10;

b /= 10;

}

if (num == a)

ret = true;

return ret;

}

public static boolean isPrime(int num) {

boolean ret = true;

if (num == 1 || num == 2 || num == 3)

ret = true;

else {

for (int i = 2; i <= Math.sqrt(num); i++) {

if (num % i == 0) {

ret = false;

break;

}

return ret;

}

~~~

# P1720 月落乌啼算钱（斐波那契数列）

![img](https://cdn.luogu.com.cn/upload/pic/507.png)

这啥？我原就觉得这东西肯定会有大神来凑热闹吧？结果真的是，一看一堆，解释的我还一时不能明白，淦！要明白还是要头发~~？

Fn={1，1，2，3，5，8，13……}说白了就是前两个数等于一，之后的数是这个数之前的两数的和

用int一直不满分，改成long或者BigInteger都可以

~~~Java

import java.math.BigInteger;

import java.util.Scanner;

public class _P1720 {

public static void main(String[] args) {

int n = new Scanner(System.in).nextInt();

BigInteger a = new BigInteger("1");

BigInteger b = new BigInteger("1");

BigInteger c = new BigInteger("0");

for (int i = 0; i < n - 2; i++) {

c = a.add(b);

a = b;

b = c;

}

System.out.println(c + ".00");

}

~~~

# P1420 最长连号

~~~java

import java.util.Scanner;

public class P1420 {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

int n = cin.nextInt(), count = 0, max = -0;

int[] arr = new int[n+1];//防止之后的数组越界，初始化时大小为n+1

for (int i = 0; i < n; i++) {

arr[i] = cin.nextInt();

}//填充数组

for (int i = 0; i < n ; i++) {

if (arr[i + 1] - arr[i] == 1) count++;//如果前后两数连号，count++

else count = 0;//否则count清零

if (count > max) max = count;//用于max用于储存最大的count，也可以用max = Math.max(max,count),一个意思

}

System.out.println(max+1);//直接输max总是比正确结果少1，改了好多前面的都不行，加上1之后就对了！

}

~~~

# P1075 [NOIP2012 普及组] 质因数分解

这个很简单嘛！用for循环找质数，然后用个变量承载最大的质数就行了，结果就超时了，他给的范围太大了

然后修改之后，既然这个数是两个质数相乘的，那么找到最小的质数除一下就好了，果然通过了！

~~~Java

import java.util.Scanner;

public class P1075 {

public static void main(String[] args) {

int n = new Scanner(System.in).nextInt(), max = 0;

for (int i = 2; i < n; i++) {

if (n % i == 0) {

System.out.println(n / i);

break;

}

~~~

# P5725 【深基4.习8】求三角形

第一个方形很好求，两个循环没太大联系，第二个三角形最难写的是内层循环里的第一个if条件，也就是根据行序数来判断每一行需要输出多少个数，否则就“ ”

~~~Java

import java.util.Scanner;

public class P5725 {

public static void main(String[] args) {

int n = new Scanner(System.in).nextInt(), count1 = 1, count2 = 1;

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {

if (count1 < 10) {

System.out.print("0" + count1);

}

else {

System.out.print(count1);

}

count1++;

}

System.out.println();

}

System.out.println();

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= n; j++) {

if (n - i + 1 > j) { //不好想

System.out.print(" ");

}

else {

if (count2 < 10) {

System.out.print("0" + count2);

}

else {

System.out.print(count2);

}

count2++;

}

System.out.println();

}

~~~

# P4956 [COCI2017-2018#6] Davor

周一x元，周二x+k元，以此类推，一周是7x+21k元

2018年12月31日是周二，意思就是周一他还要赚x元，在52个星期筹集完，并且保证x，k为正整数

# P1427 小鱼的数字游戏

就是给出以0结尾的一串数字，将结尾的0去除然后反向输出；

创建一个动态的数组，然后从键盘上有多少数据接收并储存多少数据，查了一会并没有发现如何写

#### **问题**：用动态数组从键盘接受一组不定长度的数据

接下来是修修改改后的代码

~~~Java

import java.util.ArrayList;

import java.util.Collections;

import java.util.Scanner;

public class P1427 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

ArrayList<Integer> arr = new ArrayList<>();//如果不事先规定Integer类型会以String来存，停不下来了

for (int i = 0; i < 100; i++) {

arr.add(input.nextInt());

if (arr.get(i)==0)//以零结束，那我的循环也以零结束

break;

}

Collections.reverse(arr);//颠倒

for (int i = 0; i < arr.size()-1; i++) {

System.out.print(arr.get(i+1)+" ");//i+1直接将开头的0跳过

}

~~~

# P1047 [NOIP2005 普及组] 校门外的树

~~~Java

import java.util.Scanner;

public class P1047 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

int L = input.nextInt(), m = input.nextInt();

int[] begin = new int[m], end = new int[m], sign = new int[L + 1];

//这里由于位置由0~L，故数组应当多一位，不然答案re原因：数组过界

for (int i = 0; i <= L; i++) {

sign[i] = 1;

}

for (int i = 0; i < m; i++) {

begin[i] = input.nextInt();

end[i] = input.nextInt();

for (int j = begin[i]; j <= end[i]; j++) {

if (sign[j] == 1) sign[j] = 0;

}

int count = 0;

for (int i = 0; i <= L; i++) {

if (sign[i] == 1) count++;

}

System.out.println(count);

}

~~~

这三个re搞了我好久

# P5728 【深基5.例5】旗鼓相当的对手

~~~Java

import java.util.Scanner;

public class P5728 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

int N = input.nextInt();

int[] chin = new int[N], math = new int[N], engl = new int[N], sum = new int[N];

for (int i = 0; i < N; i++) {

chin[i] = input.nextInt();

math[i] = input.nextInt();

engl[i] = input.nextInt();

sum[i] = chin[i] + math[i] + engl[i];

}

int index = 0;

for (int i = 0; i < N; i++) {

for (int j = i + 1; j < N; j++) {//这里需要特别注意j=i+1；因为成绩对比不能够和自己进行比较

if (Math.abs(chin[i] - chin[j]) <= 5 &&

Math.abs(math[i] - math[j]) <= 5 &&

Math.abs(engl[i] - engl[j]) <= 5 &&

Math.abs(sum[i] - sum[j]) <= 10)

index++;

}

System.out.println(index);

}

~~~

# P2550 [AHOI2001]彩票摇奖

~~~Java

import java.util.Scanner;

//彩票摇奖

public class P2550 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

int n = input.nextInt();

int[] boom = new int[7], result = new int[7];

for (int i = 0; i < 7; i++) {

boom[i] = input.nextInt();

}

int[][] buy = new int[n][7];

for (int i = 0; i < n; i++) {

int count = 0;

for (int j = 0; j < 7; j++) {

buy[i][j] = input.nextInt();

for (int k = 0; k < 7; k++) {

if (buy[i][j] == boom[k]) count++;

}

if (count != 0)

result[7 - count]++;//有七个数相等才为特等奖，而结尾要求优先输出特等奖

}

for (int i = 0; i < 7; i++) {

System.out.print(result[i]+" ");

}

~~~

借鉴了此代码counter的设定，

~~~Java

import java.util.HashSet;

import java.util.Scanner;

import java.util.Set;

public class P2550 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int num = Integer.parseInt(scanner.nextLine());

String[] correctArray = scanner.nextLine().split(" ");

Set<String> set = new HashSet<>();

for (String str : correctArray) {

set.add(str);

}

int[] resultArray = new int[7];

for (int i = 0; i < num; i++) {

int counter = 0;

for (int j = 0; j < 7; j++) {

if (set.contains(scanner.next())) {

counter++;

}

if (counter != 0) {

resultArray[7-counter]++;

}

for (int i = 0; i < 6; i++) {

System.out.print(resultArray[i] + " ");

}

System.out.println(resultArray[6]);

scanner.close();

}

//https://blog.csdn.net/weixin_44048403/article/details/105438730

~~~

# P1554 梦中的统计

~~~java

import java.util.Scanner;

public class P1554 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

int M = input.nextInt(), N = input.nextInt();

int[] num = new int[10];

for (int i = M; i <= N; i++)

for (int temp = i; temp != 0; temp /= 10)

num[temp%10]++;

for (int i = 0; i < 10; i++) {

System.out.print(num[i] + " ");

}

~~~

向大佬学习，第一次看了方法，然后尝试自己做了做，发现程序老是陷入死循环，无法结束，无奈之下，再次看了大佬的代码，不仅对，而且比我的要简洁。

temp用于储存每一位上的数，然后作为num数组的角标+1，最后输出num就行

## 插曲

~~~

USACO（United States of America Computing Olympiad, 美国计算机奥林匹克竞赛) 是一项针对全世界所有的高中信息学竞赛选手的一项竞赛。这项赛事不仅可以培养学生的算法和编程思维，好的竞赛成绩还能给孩子大学申请加分。由于有些编程题跟谷歌，脸书等顶级科技公司面试题类似，好的USACO竞赛成绩对孩子以后申请实习也大有裨益。

~~~

NOIP（National Olympiad in Informatics in Provinces，全国青少年信息学奥林匹克联赛）是一项面向全国青少年的信息学竞赛和普及活动，旨在向那些在中学阶段学习的青少年普及计算机科学知识；给学校的信息技术教育课程提供动力和新的思路；给那些有才华的学生提供相互交流和学习的机会；通过竞赛和相关的活动培养和选拔优秀的计算机人才。初、高中或其他中等专业学校的学生可报名参加联赛。

~~~

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 199,271评论 5赞 466
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 83,725评论 2赞 376
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 146,252评论 0赞 328
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 53,634评论 1赞 270
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 62,549评论 5赞 359
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 47,985评论 1赞 275
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,471评论 3赞 390
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,128评论 0赞 254
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,257评论 1赞 294
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,233评论 2赞 317
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,235评论 1赞 328
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,940评论 3赞 316
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,528评论 3赞 302
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,623评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,858评论 1赞 255
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,245评论 2赞 344
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 41,790评论 2赞 339

算法第一周——洛谷

推荐阅读更多精彩内容