package 第十一届蓝桥杯;

public class C跑步训练 {
    public static void main(String[] args) {
        int target = 10000;
        int count = 0;
        boolean flag = true;
        while (true) {
            //如果小于600体力并且需要跑步，证明这一分钟跑不完
            if (target < 600 && flag){
                break;
            }
            if (flag) {
                target -= 600;
                flag = false;
            } else {
                target += 300;
                flag = true;
            }
            count++;
        }
//        System.out.println(count);
        //最后要求秒数，一分钟花费600体力，一秒花费10体力，体力除10就是剩下的跑步时间
        int time = count * 60+target/10;
        System.out.println(time);
    }
}

package 第十一届蓝桥杯B;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class B纪念日 {
    //不需要非要找12点，因为都是从0点算也是一样的
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date1 = format.parse("1921-7-23");
        Date date2 = format.parse("2020-7-1");
        int a = (int) ((date2.getTime() - date1.getTime()) / (1000*60));
        System.out.println(a);
    }
}

package 第十一届蓝桥杯B;

import java.util.Scanner;
//文件在  https://files.cnblogs.com/files/a1439775520/C大学B组.zip
public class REPEAT程序 {
    public static void main(String[] args) {
        int[] layer = new int[10000];
        int[] count = new int[10000];
        Scanner sc = new Scanner(System.in);
        int pointer = 0, result = 0, curCount = 1;
       sc.nextLine();
        layer[pointer] = -1; count[pointer] = 1;
        while (sc.hasNext()) {
            String ss = sc.nextLine();
            if (ss.equals("0")){
                break;
            }
            char[] s = ss.toCharArray();
            int n = s.length, p = 0;
            while (s[p] == ' ') p++; // 统计缩进
            // 判断是不是在一层，如果当前层数小于上一次的层数，循环的次数就要除上一次的循环数
            while (layer[pointer] >= p) curCount /= count[pointer--];
            if (s[n - 1] == ':') { // 当前行是循环
                //k为循环的次数
                int k = s[n - 2] - '0';
                //循环又往里走了一层
                pointer = pointer + 1;
                //w为循环次数
                curCount *= k;
                //a放的是当前层数是多少个空格
                //b放地是当前循环的次数
                layer[pointer] = p;count[pointer] = k;
            } else {
                //证明这个是A加值，k为A加的值
                int k = s[n - 1] - '0';
                //w是循环的次数
                result += k * curCount;
            }
        }
        System.out.println(result);
    }
}

package 第十一届蓝桥杯B;

public class E矩阵1 {
    public static void main(String[] args) {
        int n = 2020;
        //dp[i][j]表示，从i个数选j个数
        int[][] dp = new int[3000][3000];
        dp[1][1] = 1; // 1必然放在第一行
        //只要保证第一行的数比第二行的数多就可以了，后面的数会越来越大，会符合小到大的规律
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i][j] += dp[i - 1][j - 1]; // 放到第一层
                if (i - j <= j) {
                    //当进入if说明，i没有超过j的两倍了，
                    // （如果超过j的两倍，说明第一行肯定比第二行少了）
                    //本身就是取一半的数字，如果超过两倍，说明取不到一半，不能参与计算
                    dp[i][j] += dp[i - 1][j];   //放到第二层
                }
                dp[i][j] %= 2020;
            }
        }
        System.out.println(dp[n][n/2]);
    }
}

package 第十一届蓝桥杯;

import java.util.Scanner;

public class G整除序列 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        while (n != 0) {
            System.out.print(n + " ");
            n = n >> 1;//等价于/2，位运算相对快一些
        }
    }
}

package 第十一届蓝桥杯B;

import java.util.Scanner;

public class G解码 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        sc.close();
        StringBuilder sb = new StringBuilder();
        char[] num = s.toCharArray();
        char temp='0';
        int count=0;
        int len = s.length();
        for (int i=0;i<len;i++){
            if(Character.isDigit(num[i])){
                count=num[i]-'0';
                for (int j=0;j<count;j++){
                    sb.append(temp);
                }
            } else{
                temp=num[i];
                if(i<len-1 && Character.isDigit(num[i+1])){
                    continue;
                } else {
                    sb.append(temp);
                }
            }
        }
        System.out.println(sb.toString());
    }
}

package 第十一届蓝桥杯;

import java.util.Scanner;

public class H走方格 {
    public static void main(String[] args) {
        //输入矩阵的宽高
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        sc.close();
        int[][] dp = new int[n][m];
        dp[0][0]=1;
        //这个规律是只能往右下走，也就是只能取左上的值
        for (int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                //第一行一列无需处理
                 if(i==0 && j==0){
                     continue;
                 }
                 //只要不是第一行就可以取上面的
                 if(i>0){
                     dp[i][j]+=dp[i-1][j];
                 }
                 //只要不是第一列就可以取左面的
                 if(j>0){

                     dp[i][j]+=dp[i][j-1];
                 }
                 //如果是偶数行列不能取值，这里是奇数，因为我的是从0开始，所以偶数的就变成了奇数
                 if((i&1)==1 && (j&1)==1){
                     dp[i][j]=0;
                 }
            }
        }
        System.out.println(dp[n-1][m-1]);
    }
}

package 第十一届蓝桥杯B;

import java.util.Scanner;

public class I整数拼接1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] num = new int[n];
        int[][] a = new int[k][10];
        int[][] b = new int[k][10];
//int aa=1111111111;
        int temp=0;
        //记录有哪些数自己和自己拼接可以为k倍
        int subtract=0;
        for (int i=0;i<n;i++){
            num[i]=sc.nextInt();
            //取余
            temp=num[i]%k;
            //余数为temp的，并且位数为当前数字相同的
            ++b[temp][getLen(num[i])];
            //求这个数*这个数的位数
            for (int j =1;j<=9;j++){
                    //a[i][j]代表%k余数为i的，后面带10的j次方（因为后面的数不知道几位，所以要把1-9位都算一下）
                ++a[((temp*((int) (Math.pow(10,j))%k))%k)][j];
            }
            //如果自身可以拼接，就纪录一下，最后减去自身拼接的数
             if(temp+(temp*(getLen(num[i])%k))%k==k){
                 subtract++;
             }
        }
        int count=0;
        for (int i=0;i<k;i++){
            for (int j =1;j<=9;j++){
                //（余数为i的并且要加上位数为j的数字）的数量*（余数为（k-i）%k并且数字为j位数的）得数量就是组合拼接的数量
                count+=a[i][j]*b[(k-i)%k][j];
            }
        }
        System.out.println(count-subtract);
    }
    //求num有几位
    public static int getLen(int num){
        int len=1;
        while (num!=0){
            num/=10;
            len*=10;
        }
        return len/10;
    }
}

package 第十一届蓝桥杯B;

import java.util.LinkedList;
import java.util.Scanner;

public class J网络分析1 {
    static int[] data ;
    static boolean[] bool ;
    static  LinkedList<LinkedList<Integer>> list = new  LinkedList<LinkedList<Integer>>();
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        data=new int[n+1];
        bool=new boolean[n+1];
        int a=0,b=0,c=0;
        for (int i =0;i<=n;i++){
            list.add(new LinkedList<>());
        }
        for (int i=0;i<m;i++){
            a=sc.nextInt();
            b=sc.nextInt();
            c=sc.nextInt();
            //网络题把他们互相联系起来
            if(a==1){
                list.get(b).add(c);
                list.get(c).add(b);
            } else{

                bool=new boolean[n+1];
                dfs(b,c);
            }
        }
        for (int i=1;i<=n;i++){
            System.out.println(data[i]);
        }
    }
//dfs遍历每一个结点
    public static void dfs(int node,int num){
        bool[node]=true;
        data[node]+=num;
        LinkedList<Integer> templist=list.get(node);
        for(int i:templist){
            if(!bool[i]){

                dfs(i,num);

            }
        }
    }


}